mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 21:36:52 +01:00
Compare commits
8
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
992e36b678 | ||
|
|
5d7c8c905b | ||
|
|
c2ad75e459 | ||
|
|
0a916b1d4b | ||
|
|
33abaf95cd | ||
|
|
20c68ef3c4 | ||
|
|
f46abae87e | ||
|
|
ae688d038d |
No files matched your search
@@ -1,142 +0,0 @@
|
|||||||
#!/usr/bin/env bash
|
|
||||||
#
|
|
||||||
# Backport a merged PR to a release branch.
|
|
||||||
#
|
|
||||||
# Cherry-picks the merge commit of a merged PR onto release-1.11 and opens a
|
|
||||||
# backport PR, mirroring the shape of #1842.
|
|
||||||
#
|
|
||||||
# Usage: ./backport.sh <pr-number> [target-version] [--continue]
|
|
||||||
# pr-number The merged PR to backport
|
|
||||||
# target-version Release version to target (default: 1.11)
|
|
||||||
# --continue Resume after resolving cherry-pick conflicts: assumes the
|
|
||||||
# fixes are staged, runs `git cherry-pick --continue`, and
|
|
||||||
# proceeds to push and open the backport PR.
|
|
||||||
#
|
|
||||||
# Requires: gh (authenticated), git, jq.
|
|
||||||
|
|
||||||
set -euo pipefail
|
|
||||||
|
|
||||||
PR_NUMBER=${1:?usage: backport.sh <pr-number> [target-version] [--continue]}
|
|
||||||
shift
|
|
||||||
CONTINUE=0
|
|
||||||
TARGET_VERSION=""
|
|
||||||
for arg in "$@"; do
|
|
||||||
case "$arg" in
|
|
||||||
--continue) CONTINUE=1 ;;
|
|
||||||
*) TARGET_VERSION=$arg ;;
|
|
||||||
esac
|
|
||||||
done
|
|
||||||
|
|
||||||
for cmd in gh git jq; do
|
|
||||||
command -v "$cmd" >/dev/null || { echo "error: $cmd is required" >&2; exit 1; }
|
|
||||||
done
|
|
||||||
|
|
||||||
# Pull the source PR's metadata. Refuse to backport a PR that never merged.
|
|
||||||
pr_json=$(gh pr view "$PR_NUMBER" --json title,body,mergedAt,mergeCommit,milestone)
|
|
||||||
PR_TITLE=$(jq -r '.title' <<<"$pr_json")
|
|
||||||
PR_BODY=$(jq -r '.body' <<<"$pr_json")
|
|
||||||
MERGE_SHA=$(jq -r '.mergeCommit.oid // empty' <<<"$pr_json")
|
|
||||||
PR_MILESTONE=$(jq -r '.milestone.title // empty' <<<"$pr_json")
|
|
||||||
|
|
||||||
if [ "$(jq -r '.mergedAt // empty' <<<"$pr_json")" = "" ] || [ -z "$MERGE_SHA" ]; then
|
|
||||||
echo "error: PR #${PR_NUMBER} is not merged (no merge commit to cherry-pick)" >&2
|
|
||||||
exit 1
|
|
||||||
fi
|
|
||||||
|
|
||||||
# Default the target to one minor below the PR's milestone: a PR landing in
|
|
||||||
# v1.12.0 backports to release-1.11. An explicit target-version arg overrides.
|
|
||||||
if [ -z "$TARGET_VERSION" ]; then
|
|
||||||
if [[ $PR_MILESTONE =~ ^v?([0-9]+)\.([0-9]+) ]]; then
|
|
||||||
TARGET_VERSION="${BASH_REMATCH[1]}.$(( BASH_REMATCH[2] - 1 ))"
|
|
||||||
else
|
|
||||||
echo "error: PR #${PR_NUMBER} has no v<major>.<minor>.* milestone to infer the target from." >&2
|
|
||||||
echo "Pass the target version explicitly, e.g. $0 ${PR_NUMBER} 1.11" >&2
|
|
||||||
exit 1
|
|
||||||
fi
|
|
||||||
fi
|
|
||||||
TARGET_BRANCH="release-${TARGET_VERSION}"
|
|
||||||
|
|
||||||
# Slug from the PR title: lower-case, non-alphanumerics to dashes, trimmed.
|
|
||||||
slug=$(printf '%s' "$PR_TITLE" \
|
|
||||||
| tr '[:upper:]' '[:lower:]' \
|
|
||||||
| sed -E 's/[^a-z0-9]+/-/g; s/^-+//; s/-+$//' \
|
|
||||||
| cut -c1-50 \
|
|
||||||
| sed -E 's/-+$//')
|
|
||||||
BRANCH="backport-${TARGET_VERSION//./-}-${slug}"
|
|
||||||
|
|
||||||
if [ "$CONTINUE" -eq 1 ]; then
|
|
||||||
# Resuming: the branch already exists and a cherry-pick is mid-conflict.
|
|
||||||
current=$(git rev-parse --abbrev-ref HEAD)
|
|
||||||
if [ "$current" != "$BRANCH" ]; then
|
|
||||||
echo "error: --continue expects to be on ${BRANCH}, but HEAD is ${current}" >&2
|
|
||||||
exit 1
|
|
||||||
fi
|
|
||||||
echo "Resuming backport of #${PR_NUMBER} on ${BRANCH}"
|
|
||||||
# Conflicts assumed resolved and staged; core.editor=true keeps the commit message.
|
|
||||||
git -c core.editor=true cherry-pick --continue
|
|
||||||
else
|
|
||||||
# A fresh run switches branches and cherry-picks, so tracked changes must be
|
|
||||||
# clean. Untracked files are fine, and --continue is exempt (its resolved
|
|
||||||
# conflicts are meant to be staged).
|
|
||||||
if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
|
|
||||||
echo "error: working tree has uncommitted changes to tracked files; commit or stash them first." >&2
|
|
||||||
exit 1
|
|
||||||
fi
|
|
||||||
|
|
||||||
echo "Backporting #${PR_NUMBER} (${MERGE_SHA}) onto ${TARGET_BRANCH} as ${BRANCH}"
|
|
||||||
|
|
||||||
git fetch origin
|
|
||||||
git checkout -b "$BRANCH" "origin/${TARGET_BRANCH}"
|
|
||||||
|
|
||||||
# -m 1 handles a real merge commit; plain cherry-pick handles a squash merge.
|
|
||||||
if ! { git cherry-pick -x -m 1 "$MERGE_SHA" 2>/dev/null || git cherry-pick -x "$MERGE_SHA"; }; then
|
|
||||||
echo "error: ${MERGE_SHA} did not cherry-pick cleanly onto ${TARGET_BRANCH}." >&2
|
|
||||||
echo "Resolve the conflicts, 'git add' them, then re-run:" >&2
|
|
||||||
echo " $0 ${PR_NUMBER} ${TARGET_VERSION} --continue" >&2
|
|
||||||
exit 1
|
|
||||||
fi
|
|
||||||
fi
|
|
||||||
|
|
||||||
title="backport v${TARGET_VERSION}: ${PR_TITLE}"
|
|
||||||
body=$(printf 'Backport from #%s to release v%s\n\n---\n\n%s' \
|
|
||||||
"$PR_NUMBER" "$TARGET_VERSION" "$PR_BODY")
|
|
||||||
|
|
||||||
# Highest open milestone matching v<version>.* (e.g. v1.11.1), if any.
|
|
||||||
MILESTONE=$(gh api "repos/{owner}/{repo}/milestones?state=open" \
|
|
||||||
--jq ".[].title | select(startswith(\"v${TARGET_VERSION}.\"))" \
|
|
||||||
| sort -V | tail -n1)
|
|
||||||
milestone_args=()
|
|
||||||
if [ -n "$MILESTONE" ]; then
|
|
||||||
milestone_args=(--milestone "$MILESTONE")
|
|
||||||
else
|
|
||||||
echo "warning: no open milestone matching v${TARGET_VERSION}.* found; PR will have no milestone" >&2
|
|
||||||
fi
|
|
||||||
|
|
||||||
echo
|
|
||||||
echo "About to run:"
|
|
||||||
printf ' git push -u --force-with-lease origin %q\n' "$BRANCH"
|
|
||||||
printf ' gh pr create --base %q --head %q --title %q --body %q' \
|
|
||||||
"$TARGET_BRANCH" "$BRANCH" "$title" "$body"
|
|
||||||
[ -n "$MILESTONE" ] && printf ' --milestone %q' "$MILESTONE"
|
|
||||||
printf '\n'
|
|
||||||
echo
|
|
||||||
read -r -p "Open this pull request? [y/N] " reply
|
|
||||||
case "$reply" in
|
|
||||||
[yY] | [yY][eE][sS]) ;;
|
|
||||||
*) echo "Aborted. The cherry-pick is on local branch ${BRANCH}; push it manually if desired."; exit 0 ;;
|
|
||||||
esac
|
|
||||||
|
|
||||||
git push -u --force-with-lease origin "$BRANCH"
|
|
||||||
|
|
||||||
gh pr create \
|
|
||||||
--base "$TARGET_BRANCH" \
|
|
||||||
--head "$BRANCH" \
|
|
||||||
--title "$title" \
|
|
||||||
--body "$body" \
|
|
||||||
${milestone_args[@]+"${milestone_args[@]}"}
|
|
||||||
|
|
||||||
# The backport now exists, so drop the label that flagged this PR for one.
|
|
||||||
gh pr edit "$PR_NUMBER" --remove-label needs-backport
|
|
||||||
|
|
||||||
# Switch back to the original branch we were on before doing the backport
|
|
||||||
git checkout -
|
|
||||||
@@ -98,7 +98,7 @@ jobs:
|
|||||||
# WSL2 + Ubuntu so the smoke can run a real linux peer with its own
|
# WSL2 + Ubuntu so the smoke can run a real linux peer with its own
|
||||||
# netns. iputils-ping is needed for the in-WSL ping check. WSL1 has no
|
# netns. iputils-ping is needed for the in-WSL ping check. WSL1 has no
|
||||||
# real kernel and would lack /dev/net/tun, so we have to force WSL2.
|
# real kernel and would lack /dev/net/tun, so we have to force WSL2.
|
||||||
- uses: Vampire/setup-wsl@v7
|
- uses: Vampire/setup-wsl@v3
|
||||||
with:
|
with:
|
||||||
distribution: Ubuntu-24.04
|
distribution: Ubuntu-24.04
|
||||||
additional-packages: iputils-ping iproute2
|
additional-packages: iputils-ping iproute2
|
||||||
|
|||||||
+31
-32
@@ -20,45 +20,44 @@ jobs:
|
|||||||
|
|
||||||
- uses: actions/checkout@v7
|
- uses: actions/checkout@v7
|
||||||
|
|
||||||
- uses: actions/setup-go@v7
|
|
||||||
with:
|
|
||||||
go-version: '1.26'
|
|
||||||
check-latest: true
|
|
||||||
|
|
||||||
- name: Smoke Docker
|
|
||||||
run: make smoke-docker
|
|
||||||
|
|
||||||
- name: Smoke Docker IPv6 overlay
|
|
||||||
run: make smoke-docker-ipv6
|
|
||||||
|
|
||||||
- name: Smoke Relay Docker
|
|
||||||
run: make smoke-relay-docker
|
|
||||||
|
|
||||||
- name: Smoke Docker boringcrypto
|
|
||||||
run: make boringcrypto smoke-docker
|
|
||||||
|
|
||||||
- name: Smoke Docker fips140
|
|
||||||
run: make fips140-all GOALS=smoke-docker
|
|
||||||
|
|
||||||
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
|
- uses: actions/setup-go@v7
|
||||||
with:
|
with:
|
||||||
go-version: '1.26'
|
go-version: '1.26'
|
||||||
check-latest: true
|
check-latest: true
|
||||||
|
|
||||||
- name: build
|
- name: build
|
||||||
run: make bin
|
run: make bin-docker CGO_ENABLED=1 BUILD_ARGS=-race
|
||||||
|
|
||||||
- name: run smoke-self
|
- name: setup docker image
|
||||||
working-directory: ./.github/workflows/smoke
|
working-directory: ./.github/workflows/smoke
|
||||||
run: ./smoke-self.sh
|
run: ./build.sh
|
||||||
|
|
||||||
|
- name: run smoke
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: ./smoke.sh
|
||||||
|
|
||||||
|
- name: setup docker image ipv6
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: SMOKE_OVERLAY_IPV6=1 ./build.sh
|
||||||
|
|
||||||
|
- name: run smoke ipv6
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: SMOKE_OVERLAY_IPV6=1 ./smoke.sh
|
||||||
|
|
||||||
|
- name: setup relay docker image
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: ./build-relay.sh
|
||||||
|
|
||||||
|
- name: run smoke relay
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: ./smoke-relay.sh
|
||||||
|
|
||||||
|
- name: setup docker image for P256
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: NAME="smoke-p256" CURVE=P256 ./build.sh
|
||||||
|
|
||||||
|
- name: run smoke-p256
|
||||||
|
working-directory: ./.github/workflows/smoke
|
||||||
|
run: NAME="smoke-p256" ./smoke.sh
|
||||||
|
|
||||||
timeout-minutes: 10
|
timeout-minutes: 10
|
||||||
@@ -1,130 +0,0 @@
|
|||||||
#!/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,19 +51,15 @@ 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,$Ip6_1/64" -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" -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,$Ip6_2/64" -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" -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.
|
||||||
@@ -86,7 +82,7 @@ tun:
|
|||||||
drop_local_broadcast: false
|
drop_local_broadcast: false
|
||||||
drop_multicast: false
|
drop_multicast: false
|
||||||
tx_queue: 500
|
tx_queue: 500
|
||||||
mtu: $Mtu
|
mtu: 1300
|
||||||
network_category: private
|
network_category: private
|
||||||
logging:
|
logging:
|
||||||
level: info
|
level: info
|
||||||
@@ -130,7 +126,7 @@ tun:
|
|||||||
drop_local_broadcast: false
|
drop_local_broadcast: false
|
||||||
drop_multicast: false
|
drop_multicast: false
|
||||||
tx_queue: 500
|
tx_queue: 500
|
||||||
mtu: $Mtu
|
mtu: 1300
|
||||||
logging:
|
logging:
|
||||||
level: info
|
level: info
|
||||||
format: text
|
format: text
|
||||||
@@ -173,7 +169,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; { 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"
|
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"
|
||||||
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
|
||||||
@@ -218,16 +214,6 @@ 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"
|
||||||
@@ -235,13 +221,6 @@ 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"
|
||||||
@@ -255,28 +234,6 @@ 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.'
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -58,14 +58,9 @@ jobs:
|
|||||||
e2e-cmd: make e2evv
|
e2e-cmd: make e2evv
|
||||||
- name: linux-boringcrypto
|
- name: linux-boringcrypto
|
||||||
os: ubuntu-latest
|
os: ubuntu-latest
|
||||||
build-cmd: make boringcrypto
|
build-cmd: make bin-boringcrypto
|
||||||
test-cmd: make boringcrypto test
|
test-cmd: make test-boringcrypto
|
||||||
e2e-cmd: make boringcrypto e2evv
|
e2e-cmd: make e2e GOEXPERIMENT=boringcrypto CGO_ENABLED=1 TEST_ENV="TEST_LOGS=1" TEST_FLAGS="-v -ldflags -checklinkname=0"
|
||||||
- name: linux-fips140
|
|
||||||
os: ubuntu-latest
|
|
||||||
build-cmd: make fips140-all
|
|
||||||
test-cmd: make fips140-all GOALS=test
|
|
||||||
e2e-cmd: make fips140-all GOALS=e2evv
|
|
||||||
- name: linux-pkcs11
|
- name: linux-pkcs11
|
||||||
os: ubuntu-latest
|
os: ubuntu-latest
|
||||||
build-cmd: make bin-pkcs11
|
build-cmd: make bin-pkcs11
|
||||||
|
|||||||
@@ -7,13 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
|||||||
|
|
||||||
## [Unreleased]
|
## [Unreleased]
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- `create-tunnel -address <ip:port>` panicked on a nil RemoteList and, over the ssh debug server, took nebula
|
|
||||||
down with it. A hostinfo returned by StartHandshake had no RemoteList until the handshake loop's first
|
|
||||||
pass attached one, and `create-tunnel -address` set the remote before that. The list is now attached when
|
|
||||||
the handshake starts, so a pending hostinfo never exists without one.
|
|
||||||
|
|
||||||
## [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.
|
||||||
|
|||||||
@@ -72,17 +72,6 @@ ALL_CROSS_LINUX_ARM = linux-arm-5 linux-arm-6 linux-arm-7 linux-arm64
|
|||||||
ALL_CROSS_LINUX_MIPS = linux-mips linux-mipsle linux-mips64 linux-mips64le linux-mips-softfloat
|
ALL_CROSS_LINUX_MIPS = linux-mips linux-mipsle linux-mips64 linux-mips64le linux-mips-softfloat
|
||||||
ALL_CROSS_LINUX_OTHER = linux-386 linux-ppc64le linux-riscv64 linux-loong64
|
ALL_CROSS_LINUX_OTHER = linux-386 linux-ppc64le linux-riscv64 linux-loong64
|
||||||
|
|
||||||
# Based on section 2.2 of the Go Cryptographic Module CVMP Security Policy #5247
|
|
||||||
ALL_FIPS140 = linux-amd64-fips140 \
|
|
||||||
linux-arm64-fips140 \
|
|
||||||
windows-amd64-fips140 \
|
|
||||||
windows-arm64-fips140 \
|
|
||||||
darwin-arm64-fips140 \
|
|
||||||
freebsd-amd64-fips140 \
|
|
||||||
linux-arm-7-fips140 \
|
|
||||||
linux-mips64-fips140 \
|
|
||||||
linux-ppc64le-fips140
|
|
||||||
|
|
||||||
e2e:
|
e2e:
|
||||||
$(TEST_ENV) go test -tags=e2e_testing -count=1 $(TEST_FLAGS) ./e2e
|
$(TEST_ENV) go test -tags=e2e_testing -count=1 $(TEST_FLAGS) ./e2e
|
||||||
|
|
||||||
@@ -148,8 +137,6 @@ release-netbsd: $(ALL_NETBSD:%=build/nebula-%.tar.gz)
|
|||||||
|
|
||||||
release-boringcrypto: build/nebula-linux-$(shell go env GOARCH)-boringcrypto.tar.gz
|
release-boringcrypto: build/nebula-linux-$(shell go env GOARCH)-boringcrypto.tar.gz
|
||||||
|
|
||||||
release-fips140: $(ALL_FIPS140:%=build/nebula-%.tar.gz)
|
|
||||||
|
|
||||||
BUILD_ARGS += -trimpath
|
BUILD_ARGS += -trimpath
|
||||||
|
|
||||||
bin-windows: build/windows-amd64/nebula.exe build/windows-amd64/nebula-cert.exe
|
bin-windows: build/windows-amd64/nebula.exe build/windows-amd64/nebula-cert.exe
|
||||||
@@ -170,24 +157,17 @@ bin-freebsd-arm64: build/freebsd-arm64/nebula build/freebsd-arm64/nebula-cert
|
|||||||
bin-boringcrypto: build/linux-$(shell go env GOARCH)-boringcrypto/nebula build/linux-$(shell go env GOARCH)-boringcrypto/nebula-cert
|
bin-boringcrypto: build/linux-$(shell go env GOARCH)-boringcrypto/nebula build/linux-$(shell go env GOARCH)-boringcrypto/nebula-cert
|
||||||
mv $? .
|
mv $? .
|
||||||
|
|
||||||
bin-fips140: build/linux-$(shell go env GOARCH)-fips140/nebula build/linux-$(shell go env GOARCH)-fips140/nebula-cert
|
|
||||||
mv $? .
|
|
||||||
|
|
||||||
bin-pkcs11: BUILD_ARGS += -tags pkcs11
|
bin-pkcs11: BUILD_ARGS += -tags pkcs11
|
||||||
bin-pkcs11: CGO_ENABLED = 1
|
bin-pkcs11: CGO_ENABLED = 1
|
||||||
bin-pkcs11: bin
|
bin-pkcs11: bin
|
||||||
|
|
||||||
# Build with the pprof debug server (serves on :6060). See startPprofServer.
|
|
||||||
debug: BUILD_ARGS += -tags debug
|
|
||||||
debug: bin
|
|
||||||
|
|
||||||
bin:
|
bin:
|
||||||
$(GOENV) go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula${NEBULA_CMD_SUFFIX} ${NEBULA_CMD_PATH}
|
go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula${NEBULA_CMD_SUFFIX} ${NEBULA_CMD_PATH}
|
||||||
$(GOENV) go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula-cert${NEBULA_CMD_SUFFIX} ./cmd/nebula-cert
|
go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula-cert${NEBULA_CMD_SUFFIX} ./cmd/nebula-cert
|
||||||
|
|
||||||
install:
|
install:
|
||||||
$(GOENV) go install $(BUILD_ARGS) -ldflags "$(LDFLAGS)" ${NEBULA_CMD_PATH}
|
go install $(BUILD_ARGS) -ldflags "$(LDFLAGS)" ${NEBULA_CMD_PATH}
|
||||||
$(GOENV) go install $(BUILD_ARGS) -ldflags "$(LDFLAGS)" ./cmd/nebula-cert
|
go install $(BUILD_ARGS) -ldflags "$(LDFLAGS)" ./cmd/nebula-cert
|
||||||
|
|
||||||
build/linux-arm-%: GOENV += GOARM=$(word 3, $(subst -, ,$*))
|
build/linux-arm-%: GOENV += GOARM=$(word 3, $(subst -, ,$*))
|
||||||
build/linux-mips-%: GOENV += GOMIPS=$(word 3, $(subst -, ,$*))
|
build/linux-mips-%: GOENV += GOMIPS=$(word 3, $(subst -, ,$*))
|
||||||
@@ -198,11 +178,8 @@ build/linux-mips-softfloat/%: LDFLAGS += -s -w
|
|||||||
# boringcrypto
|
# boringcrypto
|
||||||
build/linux-amd64-boringcrypto/%: GOENV += GOEXPERIMENT=boringcrypto CGO_ENABLED=1
|
build/linux-amd64-boringcrypto/%: GOENV += GOEXPERIMENT=boringcrypto CGO_ENABLED=1
|
||||||
build/linux-arm64-boringcrypto/%: GOENV += GOEXPERIMENT=boringcrypto CGO_ENABLED=1
|
build/linux-arm64-boringcrypto/%: GOENV += GOEXPERIMENT=boringcrypto CGO_ENABLED=1
|
||||||
|
build/linux-amd64-boringcrypto/%: LDFLAGS += -checklinkname=0
|
||||||
# fips140
|
build/linux-arm64-boringcrypto/%: LDFLAGS += -checklinkname=0
|
||||||
FIPSVERSION = v1.0.0
|
|
||||||
$(foreach _rule, $(ALL_FIPS140), build/$(_rule)/%): GOENV += GOFIPS140=$(FIPSVERSION)
|
|
||||||
$(foreach _rule, $(ALL_FIPS140), build/$(_rule)/%): BUILD_ARGS += -tags fips140enforce
|
|
||||||
|
|
||||||
build/%/nebula: .FORCE
|
build/%/nebula: .FORCE
|
||||||
GOOS=$(firstword $(subst -, , $*)) \
|
GOOS=$(firstword $(subst -, , $*)) \
|
||||||
@@ -233,7 +210,10 @@ vet:
|
|||||||
go vet $(VET_FLAGS) -v ./...
|
go vet $(VET_FLAGS) -v ./...
|
||||||
|
|
||||||
test:
|
test:
|
||||||
$(TEST_ENV) go test $(TEST_FLAGS) -v ./...
|
go test -v ./...
|
||||||
|
|
||||||
|
test-boringcrypto:
|
||||||
|
GOEXPERIMENT=boringcrypto CGO_ENABLED=1 go test -ldflags "-checklinkname=0" -v ./...
|
||||||
|
|
||||||
test-pkcs11:
|
test-pkcs11:
|
||||||
CGO_ENABLED=1 go test -v -tags pkcs11 ./...
|
CGO_ENABLED=1 go test -v -tags pkcs11 ./...
|
||||||
@@ -242,14 +222,11 @@ test-cov-html:
|
|||||||
go test -coverprofile=coverage.out
|
go test -coverprofile=coverage.out
|
||||||
go tool cover -html=coverage.out
|
go tool cover -html=coverage.out
|
||||||
|
|
||||||
# The package builds only compile. The final line links an android binary so a linker-only failure
|
|
||||||
# cannot pass CI.
|
|
||||||
build-test-mobile:
|
build-test-mobile:
|
||||||
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=android go build -o /dev/null ${NEBULA_CMD_PATH}
|
|
||||||
|
|
||||||
bench:
|
bench:
|
||||||
go test -bench=.
|
go test -bench=.
|
||||||
@@ -279,75 +256,29 @@ ifeq ($(words $(MAKECMDGOALS)),1)
|
|||||||
@$(MAKE) service ${.DEFAULT_GOAL} --no-print-directory
|
@$(MAKE) service ${.DEFAULT_GOAL} --no-print-directory
|
||||||
endif
|
endif
|
||||||
|
|
||||||
# Useful to chain together, like:
|
|
||||||
# - make fips140 e2evv
|
|
||||||
# - make fips140 smoke-docker
|
|
||||||
# Use `release-fips140` to build release binaries
|
|
||||||
fips140:
|
|
||||||
@echo > $(NULL_FILE)
|
|
||||||
ifeq ($(strip $(GOFIPS140)),)
|
|
||||||
$(eval GOFIPS140 = $(FIPSVERSION))
|
|
||||||
endif
|
|
||||||
$(eval GOENV += GOFIPS140=$(GOFIPS140))
|
|
||||||
$(eval BUILD_ARGS += -tags fips140enforce)
|
|
||||||
$(eval TEST_ENV += $(GOENV))
|
|
||||||
$(eval CURVE = P256)
|
|
||||||
ifeq ($(words $(MAKECMDGOALS)),1)
|
|
||||||
@$(MAKE) fips140 GOFIPS140=$(GOFIPS140) ${.DEFAULT_GOAL} --no-print-directory
|
|
||||||
endif
|
|
||||||
|
|
||||||
# To test the future pending module, use like `make fips140-latest test`
|
|
||||||
ALL_GOFIPS140 = v1.0.0 v1.26.0 latest
|
|
||||||
define FIPS140_rule
|
|
||||||
fips140-$(1): GOFIPS140 = $(1)
|
|
||||||
fips140-$(1): fips140
|
|
||||||
endef
|
|
||||||
$(foreach _rule, $(ALL_GOFIPS140), $(eval $(call FIPS140_rule,$(_rule))))
|
|
||||||
|
|
||||||
# Iterate and run the goals for all fips versions, like `make fips140-all GOALS=test`
|
|
||||||
fips140-all:
|
|
||||||
@$(foreach _v,$(ALL_GOFIPS140),$(MAKE) fips140-$(_v) $(GOALS) &&) true
|
|
||||||
|
|
||||||
# Useful to chain together, like:
|
|
||||||
# - make boringcrypto e2evv
|
|
||||||
# - make boringcrypto smoke-docker
|
|
||||||
# Use `release-boringcrypto` or `bin-boringcrypto` to build release binaries
|
|
||||||
boringcrypto:
|
|
||||||
@echo > $(NULL_FILE)
|
|
||||||
$(eval GOENV += GOEXPERIMENT=boringcrypto CGO_ENABLED=1)
|
|
||||||
$(eval TEST_ENV += $(GOENV))
|
|
||||||
$(eval CURVE = P256)
|
|
||||||
ifeq ($(words $(MAKECMDGOALS)),1)
|
|
||||||
@$(MAKE) boringcrypto ${.DEFAULT_GOAL} --no-print-directory
|
|
||||||
endif
|
|
||||||
|
|
||||||
bin-docker: bin build/linux-amd64/nebula build/linux-amd64/nebula-cert
|
bin-docker: bin build/linux-amd64/nebula build/linux-amd64/nebula-cert
|
||||||
|
|
||||||
smoke-docker: BUILD_ARGS += -race
|
|
||||||
smoke-docker: GOENV += CGO_ENABLED=1
|
|
||||||
smoke-docker: bin-docker
|
smoke-docker: bin-docker
|
||||||
# This is so we can limit `fips140` smoke test to just P256 curve.
|
cd .github/workflows/smoke/ && ./build.sh
|
||||||
if [ "$(CURVE)" != "P256" ]; then cd .github/workflows/smoke/ && $(GOENV) ./build.sh; fi
|
cd .github/workflows/smoke/ && ./smoke.sh
|
||||||
if [ "$(CURVE)" != "P256" ]; then cd .github/workflows/smoke/ && $(GOENV) ./smoke.sh; fi
|
cd .github/workflows/smoke/ && NAME="smoke-p256" CURVE="P256" ./build.sh
|
||||||
cd .github/workflows/smoke/ && $(GOENV) NAME="smoke-p256" CURVE="P256" ./build.sh
|
cd .github/workflows/smoke/ && NAME="smoke-p256" ./smoke.sh
|
||||||
cd .github/workflows/smoke/ && $(GOENV) NAME="smoke-p256" ./smoke.sh
|
|
||||||
|
|
||||||
smoke-relay-docker: BUILD_ARGS += -race
|
|
||||||
smoke-relay-docker: GOENV += CGO_ENABLED=1
|
|
||||||
smoke-relay-docker: bin-docker
|
smoke-relay-docker: bin-docker
|
||||||
cd .github/workflows/smoke/ && $(GOENV) ./build-relay.sh
|
cd .github/workflows/smoke/ && ./build-relay.sh
|
||||||
cd .github/workflows/smoke/ && $(GOENV) ./smoke-relay.sh
|
cd .github/workflows/smoke/ && ./smoke-relay.sh
|
||||||
|
|
||||||
smoke-docker-ipv6: export SMOKE_OVERLAY_IPV6 = 1
|
smoke-docker-ipv6: export SMOKE_OVERLAY_IPV6 = 1
|
||||||
smoke-docker-ipv6: smoke-docker
|
smoke-docker-ipv6: smoke-docker
|
||||||
|
|
||||||
smoke-self: bin
|
smoke-docker-race: BUILD_ARGS = -race
|
||||||
cd .github/workflows/smoke/ && ./smoke-self.sh
|
smoke-docker-race: CGO_ENABLED = 1
|
||||||
|
smoke-docker-race: smoke-docker
|
||||||
|
|
||||||
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 bin-windows bin-windows-arm64 bin-darwin bin-freebsd bin-freebsd-arm64 bin-boringcrypto bin-fips140 bin-pkcs11 bin-docker boringcrypto build-test-mobile debug docker e2e e2ev e2evv e2evvv e2evvvv e2e-bench fips140 fips140-all $(ALL_GOFIPS140:%=fips140-%) install proto release release-linux release-freebsd release-openbsd release-netbsd release-boringcrypto release-fips140 service smoke-docker smoke-relay-docker smoke-docker-ipv6 smoke-self test test-pkcs11 test-cov-html vet 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 test test-cov-html smoke-vagrant/%
|
||||||
.DEFAULT_GOAL := bin
|
.DEFAULT_GOAL := bin
|
||||||
@@ -145,27 +145,17 @@ To build nebula for a specific platform (ex, Windows):
|
|||||||
|
|
||||||
See the [Makefile](Makefile) for more details on build targets
|
See the [Makefile](Makefile) for more details on build targets
|
||||||
|
|
||||||
## Curve P256 and FIPS 140-3 mode
|
## Curve P256 and BoringCrypto
|
||||||
|
|
||||||
The default curve used for cryptographic handshakes and signatures is Curve25519. This is the recommended setting for most users. If your deployment has certain compliance requirements, you have the option of creating your CA using `nebula-cert ca -curve P256` to use NIST Curve P256. The CA will then sign certificates using ECDSA P256, and any hosts using these certificates will use P256 for ECDH handshakes.
|
The default curve used for cryptographic handshakes and signatures is Curve25519. This is the recommended setting for most users. If your deployment has certain compliance requirements, you have the option of creating your CA using `nebula-cert ca -curve P256` to use NIST Curve P256. The CA will then sign certificates using ECDSA P256, and any hosts using these certificates will use P256 for ECDH handshakes.
|
||||||
|
|
||||||
Nebula can be built to support the [FIPS 140-3](https://go.dev/doc/security/fips140) mode of Go by running either of the following make targets. (This sets GOFIPS140=v1.0.0, which must be done at compile time so that the correct AES-GCM can be used for FIPS 140-3 enforcement mode).
|
In addition, Nebula can be built using the [BoringCrypto GOEXPERIMENT](https://github.com/golang/go/blob/go1.20/src/crypto/internal/boring/README.md) by running either of the following make targets:
|
||||||
|
|
||||||
```sh
|
|
||||||
make fips140
|
|
||||||
make fips140 test
|
|
||||||
make release-fips140
|
|
||||||
```
|
|
||||||
|
|
||||||
Nebula can also be built using the [BoringCrypto GOEXPERIMENT](https://github.com/golang/go/blob/go1.20/src/crypto/internal/boring/README.md) by running either of the following make targets.
|
|
||||||
|
|
||||||
```sh
|
```sh
|
||||||
make bin-boringcrypto
|
make bin-boringcrypto
|
||||||
make release-boringcrypto
|
make release-boringcrypto
|
||||||
```
|
```
|
||||||
|
|
||||||
NOTE: boringcrypto support is deprecated and will be removed in the next release. Users should migrate to the native FIPS 140-3 mode described above.
|
|
||||||
|
|
||||||
This is not the recommended default deployment, but may be useful based on your compliance requirements.
|
This is not the recommended default deployment, but may be useful based on your compliance requirements.
|
||||||
|
|
||||||
## Credits
|
## Credits
|
||||||
|
|||||||
@@ -79,7 +79,13 @@ func (b *Bits) clearRange(startPos, count uint64) uint64 {
|
|||||||
// handle the potential partial word before pos becomes u64 aligned
|
// handle the potential partial word before pos becomes u64 aligned
|
||||||
word := pos >> 6
|
word := pos >> 6
|
||||||
bit := pos & 63
|
bit := pos & 63
|
||||||
take := min(min(uint64(64)-bit, remaining), b.length-pos)
|
take := uint64(64) - bit
|
||||||
|
if take > remaining {
|
||||||
|
take = remaining
|
||||||
|
}
|
||||||
|
if take > b.length-pos {
|
||||||
|
take = b.length - pos
|
||||||
|
}
|
||||||
var mask uint64
|
var mask uint64
|
||||||
if take == 64 {
|
if take == 64 {
|
||||||
mask = math.MaxUint64
|
mask = math.MaxUint64
|
||||||
@@ -183,7 +189,10 @@ func (b *Bits) Update(l *slog.Logger, i uint64) bool {
|
|||||||
func (b *Bits) updateSlow(l *slog.Logger, i uint64) bool {
|
func (b *Bits) updateSlow(l *slog.Logger, i uint64) bool {
|
||||||
// If i is a jump, adjust the window, record lost, update current, and return true
|
// If i is a jump, adjust the window, record lost, update current, and return true
|
||||||
if i > b.current {
|
if i > b.current {
|
||||||
end := min(i, b.current+b.length)
|
end := i
|
||||||
|
if end > b.current+b.length {
|
||||||
|
end = b.current + b.length
|
||||||
|
}
|
||||||
count := end - b.current
|
count := end - b.current
|
||||||
startPos := (b.current + 1) & b.lengthMask
|
startPos := (b.current + 1) & b.lengthMask
|
||||||
|
|
||||||
|
|||||||
+1
-1
@@ -120,7 +120,7 @@ func TestCertificate_SignP256_AlwaysNormalized(t *testing.T) {
|
|||||||
pub := elliptic.Marshal(elliptic.P256(), priv.PublicKey.X, priv.PublicKey.Y)
|
pub := elliptic.Marshal(elliptic.P256(), priv.PublicKey.X, priv.PublicKey.Y)
|
||||||
rawPriv := priv.D.FillBytes(make([]byte, 32))
|
rawPriv := priv.D.FillBytes(make([]byte, 32))
|
||||||
|
|
||||||
for i := range 1000 {
|
for i := 0; i < 1000; i++ {
|
||||||
if i&1 == 1 {
|
if i&1 == 1 {
|
||||||
tbs.Version = Version1
|
tbs.Version = Version1
|
||||||
} else {
|
} else {
|
||||||
|
|||||||
+5
-17
@@ -3,9 +3,7 @@ package main
|
|||||||
import (
|
import (
|
||||||
"crypto/ecdsa"
|
"crypto/ecdsa"
|
||||||
"crypto/elliptic"
|
"crypto/elliptic"
|
||||||
"crypto/fips140"
|
|
||||||
"crypto/rand"
|
"crypto/rand"
|
||||||
"errors"
|
|
||||||
"flag"
|
"flag"
|
||||||
"fmt"
|
"fmt"
|
||||||
"io"
|
"io"
|
||||||
@@ -46,13 +44,6 @@ type caFlags struct {
|
|||||||
subnets *string
|
subnets *string
|
||||||
}
|
}
|
||||||
|
|
||||||
func defaultCurve() string {
|
|
||||||
if fips140.Enforced() {
|
|
||||||
return "P256"
|
|
||||||
}
|
|
||||||
return "25519"
|
|
||||||
}
|
|
||||||
|
|
||||||
func newCaFlags() *caFlags {
|
func newCaFlags() *caFlags {
|
||||||
// prevent running out of memory on 32-bit systems by defaulting to
|
// prevent running out of memory on 32-bit systems by defaulting to
|
||||||
// RFC9106's recommendation for memory-constrained environments
|
// RFC9106's recommendation for memory-constrained environments
|
||||||
@@ -83,7 +74,7 @@ func newCaFlags() *caFlags {
|
|||||||
cf.argonParallelism = cf.set.Uint("argon-parallelism", 4, "Optional: Argon2 parallelism parameter used for encrypted private key passphrase")
|
cf.argonParallelism = cf.set.Uint("argon-parallelism", 4, "Optional: Argon2 parallelism parameter used for encrypted private key passphrase")
|
||||||
cf.argonIterations = cf.set.Uint("argon-iterations", defaultArgonIterations, "Optional: Argon2 iterations parameter used for encrypted private key passphrase")
|
cf.argonIterations = cf.set.Uint("argon-iterations", defaultArgonIterations, "Optional: Argon2 iterations parameter used for encrypted private key passphrase")
|
||||||
cf.encryption = cf.set.Bool("encrypt", false, "Optional: prompt for passphrase and write out-key in an encrypted format")
|
cf.encryption = cf.set.Bool("encrypt", false, "Optional: prompt for passphrase and write out-key in an encrypted format")
|
||||||
cf.curve = cf.set.String("curve", defaultCurve(), "EdDSA/ECDSA Curve (25519, P256)")
|
cf.curve = cf.set.String("curve", "25519", "EdDSA/ECDSA Curve (25519, P256)")
|
||||||
cf.p11url = p11Flag(cf.set)
|
cf.p11url = p11Flag(cf.set)
|
||||||
|
|
||||||
cf.ips = cf.set.String("ips", "", "Deprecated, see -networks")
|
cf.ips = cf.set.String("ips", "", "Deprecated, see -networks")
|
||||||
@@ -151,7 +142,7 @@ func ca(args []string, out io.Writer, errOut io.Writer, pr PasswordReader) error
|
|||||||
|
|
||||||
var groups []string
|
var groups []string
|
||||||
if *cf.groups != "" {
|
if *cf.groups != "" {
|
||||||
for rg := range strings.SplitSeq(*cf.groups, ",") {
|
for _, rg := range strings.Split(*cf.groups, ",") {
|
||||||
g := strings.TrimSpace(rg)
|
g := strings.TrimSpace(rg)
|
||||||
if g != "" {
|
if g != "" {
|
||||||
groups = append(groups, g)
|
groups = append(groups, g)
|
||||||
@@ -171,7 +162,7 @@ func ca(args []string, out io.Writer, errOut io.Writer, pr PasswordReader) error
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *cf.networks != "" {
|
if *cf.networks != "" {
|
||||||
for rs := range strings.SplitSeq(*cf.networks, ",") {
|
for _, rs := range strings.Split(*cf.networks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -193,7 +184,7 @@ func ca(args []string, out io.Writer, errOut io.Writer, pr PasswordReader) error
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *cf.unsafeNetworks != "" {
|
if *cf.unsafeNetworks != "" {
|
||||||
for rs := range strings.SplitSeq(*cf.unsafeNetworks, ",") {
|
for _, rs := range strings.Split(*cf.unsafeNetworks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -221,7 +212,7 @@ func ca(args []string, out io.Writer, errOut io.Writer, pr PasswordReader) error
|
|||||||
if !isP11 && *cf.encryption {
|
if !isP11 && *cf.encryption {
|
||||||
passphrase = []byte(os.Getenv("NEBULA_CA_PASSPHRASE"))
|
passphrase = []byte(os.Getenv("NEBULA_CA_PASSPHRASE"))
|
||||||
if len(passphrase) == 0 {
|
if len(passphrase) == 0 {
|
||||||
for range 5 {
|
for i := 0; i < 5; i++ {
|
||||||
errOut.Write([]byte("Enter passphrase: "))
|
errOut.Write([]byte("Enter passphrase: "))
|
||||||
passphrase, err = pr.ReadPassword()
|
passphrase, err = pr.ReadPassword()
|
||||||
|
|
||||||
@@ -268,9 +259,6 @@ func ca(args []string, out io.Writer, errOut io.Writer, pr PasswordReader) error
|
|||||||
} else {
|
} else {
|
||||||
switch *cf.curve {
|
switch *cf.curve {
|
||||||
case "25519", "X25519", "Curve25519", "CURVE25519":
|
case "25519", "X25519", "Curve25519", "CURVE25519":
|
||||||
if fips140.Enforced() {
|
|
||||||
return errors.New("use of Curve25519 is not allowed in FIPS 140-only mode")
|
|
||||||
}
|
|
||||||
curve = cert.Curve_CURVE25519
|
curve = cert.Curve_CURVE25519
|
||||||
pub, rawPriv, err = ed25519.GenerateKey(rand.Reader)
|
pub, rawPriv, err = ed25519.GenerateKey(rand.Reader)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build !windows
|
//go:build !windows
|
||||||
|
// +build !windows
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
|
|||||||
@@ -1,5 +0,0 @@
|
|||||||
//go:build fips140enforce
|
|
||||||
|
|
||||||
//go:debug fips140=only
|
|
||||||
|
|
||||||
package main
|
|
||||||
@@ -1,8 +1,6 @@
|
|||||||
package main
|
package main
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"crypto/fips140"
|
|
||||||
"errors"
|
|
||||||
"flag"
|
"flag"
|
||||||
"fmt"
|
"fmt"
|
||||||
"io"
|
"io"
|
||||||
@@ -26,7 +24,7 @@ func newKeygenFlags() *keygenFlags {
|
|||||||
cf.set.Usage = func() {}
|
cf.set.Usage = func() {}
|
||||||
cf.outPubPath = cf.set.String("out-pub", "", "Required: path to write the public key to")
|
cf.outPubPath = cf.set.String("out-pub", "", "Required: path to write the public key to")
|
||||||
cf.outKeyPath = cf.set.String("out-key", "", "Required: path to write the private key to")
|
cf.outKeyPath = cf.set.String("out-key", "", "Required: path to write the private key to")
|
||||||
cf.curve = cf.set.String("curve", defaultCurve(), "ECDH Curve (25519, P256)")
|
cf.curve = cf.set.String("curve", "25519", "ECDH Curve (25519, P256)")
|
||||||
cf.p11url = p11Flag(cf.set)
|
cf.p11url = p11Flag(cf.set)
|
||||||
return &cf
|
return &cf
|
||||||
}
|
}
|
||||||
@@ -63,9 +61,6 @@ func keygen(args []string, out io.Writer, errOut io.Writer) error {
|
|||||||
} else {
|
} else {
|
||||||
switch *cf.curve {
|
switch *cf.curve {
|
||||||
case "25519", "X25519", "Curve25519", "CURVE25519":
|
case "25519", "X25519", "Curve25519", "CURVE25519":
|
||||||
if fips140.Enforced() {
|
|
||||||
return errors.New("use of Curve25519 is not allowed in FIPS 140-only mode")
|
|
||||||
}
|
|
||||||
pub, rawPriv = x25519Keypair()
|
pub, rawPriv = x25519Keypair()
|
||||||
curve = cert.Curve_CURVE25519
|
curve = cert.Curve_CURVE25519
|
||||||
case "P256":
|
case "P256":
|
||||||
|
|||||||
@@ -2,7 +2,6 @@ package main
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"crypto/ecdh"
|
"crypto/ecdh"
|
||||||
"crypto/fips140"
|
|
||||||
"crypto/rand"
|
"crypto/rand"
|
||||||
"errors"
|
"errors"
|
||||||
"flag"
|
"flag"
|
||||||
@@ -146,7 +145,7 @@ func signCert(args []string, out io.Writer, errOut io.Writer, pr PasswordReader)
|
|||||||
passphrase = []byte(os.Getenv("NEBULA_CA_PASSPHRASE"))
|
passphrase = []byte(os.Getenv("NEBULA_CA_PASSPHRASE"))
|
||||||
if len(passphrase) == 0 {
|
if len(passphrase) == 0 {
|
||||||
// ask for a passphrase until we get one
|
// ask for a passphrase until we get one
|
||||||
for range 5 {
|
for i := 0; i < 5; i++ {
|
||||||
errOut.Write([]byte("Enter passphrase: "))
|
errOut.Write([]byte("Enter passphrase: "))
|
||||||
passphrase, err = pr.ReadPassword()
|
passphrase, err = pr.ReadPassword()
|
||||||
|
|
||||||
@@ -203,7 +202,7 @@ func signCert(args []string, out io.Writer, errOut io.Writer, pr PasswordReader)
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *sf.networks != "" {
|
if *sf.networks != "" {
|
||||||
for rs := range strings.SplitSeq(*sf.networks, ",") {
|
for _, rs := range strings.Split(*sf.networks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -228,7 +227,7 @@ func signCert(args []string, out io.Writer, errOut io.Writer, pr PasswordReader)
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *sf.unsafeNetworks != "" {
|
if *sf.unsafeNetworks != "" {
|
||||||
for rs := range strings.SplitSeq(*sf.unsafeNetworks, ",") {
|
for _, rs := range strings.Split(*sf.unsafeNetworks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -247,7 +246,7 @@ func signCert(args []string, out io.Writer, errOut io.Writer, pr PasswordReader)
|
|||||||
|
|
||||||
var groups []string
|
var groups []string
|
||||||
if *sf.groups != "" {
|
if *sf.groups != "" {
|
||||||
for rg := range strings.SplitSeq(*sf.groups, ",") {
|
for _, rg := range strings.Split(*sf.groups, ",") {
|
||||||
g := strings.TrimSpace(rg)
|
g := strings.TrimSpace(rg)
|
||||||
if g != "" {
|
if g != "" {
|
||||||
groups = append(groups, g)
|
groups = append(groups, g)
|
||||||
@@ -269,10 +268,6 @@ func signCert(args []string, out io.Writer, errOut io.Writer, pr PasswordReader)
|
|||||||
}(p11Client)
|
}(p11Client)
|
||||||
}
|
}
|
||||||
|
|
||||||
if fips140.Enforced() && curve == cert.Curve_CURVE25519 {
|
|
||||||
return errors.New("use of Curve25519 is not allowed in FIPS 140-only mode")
|
|
||||||
}
|
|
||||||
|
|
||||||
if *sf.inPubPath != "" {
|
if *sf.inPubPath != "" {
|
||||||
var pubCurve cert.Curve
|
var pubCurve cert.Curve
|
||||||
rawPub, err := readInput("in-pub", *sf.inPubPath, &claims)
|
rawPub, err := readInput("in-pub", *sf.inPubPath, &claims)
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build !windows
|
//go:build !windows
|
||||||
|
// +build !windows
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
|
|||||||
@@ -1,5 +0,0 @@
|
|||||||
//go:build fips140enforce
|
|
||||||
|
|
||||||
//go:debug fips140=only
|
|
||||||
|
|
||||||
package main
|
|
||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build !windows
|
//go:build !windows
|
||||||
|
// +build !windows
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
|
|||||||
@@ -1,5 +0,0 @@
|
|||||||
//go:build fips140enforce
|
|
||||||
|
|
||||||
//go:debug fips140=only
|
|
||||||
|
|
||||||
package main
|
|
||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build !linux
|
//go:build !linux
|
||||||
|
// +build !linux
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
|
|||||||
+9
-6
@@ -5,7 +5,6 @@ import (
|
|||||||
"errors"
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
"maps"
|
|
||||||
"math"
|
"math"
|
||||||
"os"
|
"os"
|
||||||
"os/signal"
|
"os/signal"
|
||||||
@@ -155,7 +154,9 @@ func (c *C) ReloadConfig() {
|
|||||||
defer c.reloadLock.Unlock()
|
defer c.reloadLock.Unlock()
|
||||||
|
|
||||||
c.oldSettings = make(map[string]any)
|
c.oldSettings = make(map[string]any)
|
||||||
maps.Copy(c.oldSettings, c.Settings)
|
for k, v := range c.Settings {
|
||||||
|
c.oldSettings[k] = v
|
||||||
|
}
|
||||||
|
|
||||||
err := c.Load(c.path)
|
err := c.Load(c.path)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
@@ -176,7 +177,9 @@ func (c *C) ReloadConfigString(raw string) error {
|
|||||||
defer c.reloadLock.Unlock()
|
defer c.reloadLock.Unlock()
|
||||||
|
|
||||||
c.oldSettings = make(map[string]any)
|
c.oldSettings = make(map[string]any)
|
||||||
maps.Copy(c.oldSettings, c.Settings)
|
for k, v := range c.Settings {
|
||||||
|
c.oldSettings[k] = v
|
||||||
|
}
|
||||||
|
|
||||||
err := c.LoadString(raw)
|
err := c.LoadString(raw)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
@@ -213,7 +216,7 @@ func (c *C) GetStringSlice(k string, d []string) []string {
|
|||||||
}
|
}
|
||||||
|
|
||||||
v := make([]string, len(rv))
|
v := make([]string, len(rv))
|
||||||
for i := range v {
|
for i := 0; i < len(v); i++ {
|
||||||
v[i] = fmt.Sprintf("%v", rv[i])
|
v[i] = fmt.Sprintf("%v", rv[i])
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -307,8 +310,8 @@ func (c *C) IsSet(k string) bool {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (c *C) get(k string, v any) any {
|
func (c *C) get(k string, v any) any {
|
||||||
parts := strings.SplitSeq(k, ".")
|
parts := strings.Split(k, ".")
|
||||||
for p := range parts {
|
for _, p := range parts {
|
||||||
m, ok := v.(map[string]any)
|
m, ok := v.(map[string]any)
|
||||||
if !ok {
|
if !ok {
|
||||||
return nil
|
return nil
|
||||||
|
|||||||
+12
-16
@@ -105,18 +105,11 @@ func (cm *connectionManager) getInactivityTimeout() time.Duration {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (cm *connectionManager) In(h *HostInfo) {
|
func (cm *connectionManager) In(h *HostInfo) {
|
||||||
h.markIn()
|
h.in.Store(true)
|
||||||
}
|
}
|
||||||
|
|
||||||
// OutNoRebind records outbound traffic without consuming the rebind epoch, for relayed sends: the direct path
|
func (cm *connectionManager) Out(h *HostInfo) {
|
||||||
// to the relay consumes the edge, the via send must not.
|
h.out.Store(true)
|
||||||
func (cm *connectionManager) OutNoRebind(h *HostInfo) {
|
|
||||||
h.markOutOnly()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Out records outbound traffic and reports whether we rebound since this tunnel last sent
|
|
||||||
func (cm *connectionManager) Out(h *HostInfo) bool {
|
|
||||||
return h.markOut(cm.intf.rebindEpoch.Load())
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cm *connectionManager) RelayUsed(localIndex uint32) {
|
func (cm *connectionManager) RelayUsed(localIndex uint32) {
|
||||||
@@ -135,7 +128,8 @@ func (cm *connectionManager) RelayUsed(localIndex uint32) {
|
|||||||
// getAndResetTrafficCheck returns if there was any inbound or outbound traffic within the last tick and
|
// getAndResetTrafficCheck returns if there was any inbound or outbound traffic within the last tick and
|
||||||
// resets the state for this local index
|
// resets the state for this local index
|
||||||
func (cm *connectionManager) getAndResetTrafficCheck(h *HostInfo, now time.Time) (bool, bool) {
|
func (cm *connectionManager) getAndResetTrafficCheck(h *HostInfo, now time.Time) (bool, bool) {
|
||||||
in, out := h.takeTraffic()
|
in := h.in.Swap(false)
|
||||||
|
out := h.out.Swap(false)
|
||||||
if in || out {
|
if in || out {
|
||||||
h.lastUsed = now
|
h.lastUsed = now
|
||||||
}
|
}
|
||||||
@@ -174,8 +168,10 @@ func (cm *connectionManager) doTrafficCheck(localIndex uint32, p, nb, out []byte
|
|||||||
|
|
||||||
switch decision {
|
switch decision {
|
||||||
case deleteTunnel:
|
case deleteTunnel:
|
||||||
// Local delete only, clearing the lighthouse cache if this was the last hostinfo for the vpn addr
|
if cm.hostMap.DeleteHostInfo(hostinfo) {
|
||||||
cm.intf.closeTunnel(hostinfo)
|
// Only clearing the lighthouse cache if this is the last hostinfo for this vpn ip in the hostmap
|
||||||
|
cm.intf.lightHouse.DeleteVpnAddrs(hostinfo.vpnAddrs)
|
||||||
|
}
|
||||||
|
|
||||||
case closeTunnel:
|
case closeTunnel:
|
||||||
cm.intf.sendCloseTunnel(hostinfo)
|
cm.intf.sendCloseTunnel(hostinfo)
|
||||||
@@ -350,7 +346,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
|
|||||||
"tunnelCheck", m{"state": "alive", "method": "passive"},
|
"tunnelCheck", m{"state": "alive", "method": "passive"},
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
hostinfo.setPendingDeletion(false)
|
hostinfo.pendingDeletion.Store(false)
|
||||||
|
|
||||||
if mainHostInfo {
|
if mainHostInfo {
|
||||||
decision = tryRehandshake
|
decision = tryRehandshake
|
||||||
@@ -373,7 +369,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
|
|||||||
return decision, hostinfo, primary
|
return decision, hostinfo, primary
|
||||||
}
|
}
|
||||||
|
|
||||||
if hostinfo.isPendingDeletion() {
|
if hostinfo.pendingDeletion.Load() {
|
||||||
// We have already sent a test packet and nothing was returned, this hostinfo is dead
|
// We have already sent a test packet and nothing was returned, this hostinfo is dead
|
||||||
hostinfo.logger(cm.l).Info("Tunnel status",
|
hostinfo.logger(cm.l).Info("Tunnel status",
|
||||||
"tunnelCheck", m{"state": "dead", "method": "active"},
|
"tunnelCheck", m{"state": "dead", "method": "active"},
|
||||||
@@ -424,7 +420,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
hostinfo.setPendingDeletion(true)
|
hostinfo.pendingDeletion.Store(true)
|
||||||
cm.trafficTimer.Add(hostinfo.localIndexId, cm.pendingDeletionInterval)
|
cm.trafficTimer.Add(hostinfo.localIndexId, cm.pendingDeletionInterval)
|
||||||
return decision, hostinfo, nil
|
return decision, hostinfo, nil
|
||||||
}
|
}
|
||||||
|
|||||||
+36
-39
@@ -7,7 +7,6 @@ import (
|
|||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/rcrowley/go-metrics"
|
|
||||||
"github.com/slackhq/nebula/cert"
|
"github.com/slackhq/nebula/cert"
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/overlay/overlaytest"
|
"github.com/slackhq/nebula/overlay/overlaytest"
|
||||||
@@ -22,8 +21,6 @@ func newTestLighthouse() *LightHouse {
|
|||||||
l: test.NewLogger(),
|
l: test.NewLogger(),
|
||||||
addrMap: map[netip.Addr]*RemoteList{},
|
addrMap: map[netip.Addr]*RemoteList{},
|
||||||
queryChan: make(chan netip.Addr, 10),
|
queryChan: make(chan netip.Addr, 10),
|
||||||
// Nothing drains queryChan here, so an 11th query is dropped.
|
|
||||||
queryDropped: metrics.NilCounter{},
|
|
||||||
}
|
}
|
||||||
lighthouses := []netip.Addr{}
|
lighthouses := []netip.Addr{}
|
||||||
staticList := map[netip.Addr]struct{}{}
|
staticList := map[netip.Addr]struct{}{}
|
||||||
@@ -89,25 +86,25 @@ func Test_NewConnectionManagerTest(t *testing.T) {
|
|||||||
// We saw traffic out to vpnIp
|
// We saw traffic out to vpnIp
|
||||||
nc.Out(hostinfo)
|
nc.Out(hostinfo)
|
||||||
nc.In(hostinfo)
|
nc.In(hostinfo)
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
||||||
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
||||||
assert.True(t, hostinfo.sentSinceCheck())
|
assert.True(t, hostinfo.out.Load())
|
||||||
assert.True(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.True(t, hostinfo.in.Load())
|
||||||
|
|
||||||
// Do a traffic check tick, should not be pending deletion but should not have any in/out packets recorded
|
// Do a traffic check tick, should not be pending deletion but should not have any in/out packets recorded
|
||||||
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
|
|
||||||
// Do another traffic check tick, this host should be pending deletion now
|
// Do another traffic check tick, this host should be pending deletion now
|
||||||
nc.Out(hostinfo)
|
nc.Out(hostinfo)
|
||||||
assert.True(t, hostinfo.sentSinceCheck())
|
assert.True(t, hostinfo.out.Load())
|
||||||
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
||||||
assert.True(t, hostinfo.isPendingDeletion())
|
assert.True(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
||||||
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
||||||
|
|
||||||
@@ -171,33 +168,33 @@ func Test_NewConnectionManagerTest2(t *testing.T) {
|
|||||||
// We saw traffic out to vpnIp
|
// We saw traffic out to vpnIp
|
||||||
nc.Out(hostinfo)
|
nc.Out(hostinfo)
|
||||||
nc.In(hostinfo)
|
nc.In(hostinfo)
|
||||||
assert.True(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.True(t, hostinfo.in.Load())
|
||||||
assert.True(t, hostinfo.sentSinceCheck())
|
assert.True(t, hostinfo.out.Load())
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
||||||
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
||||||
|
|
||||||
// Do a traffic check tick, should not be pending deletion but should not have any in/out packets recorded
|
// Do a traffic check tick, should not be pending deletion but should not have any in/out packets recorded
|
||||||
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
|
|
||||||
// Do another traffic check tick, this host should be pending deletion now
|
// Do another traffic check tick, this host should be pending deletion now
|
||||||
nc.Out(hostinfo)
|
nc.Out(hostinfo)
|
||||||
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
||||||
assert.True(t, hostinfo.isPendingDeletion())
|
assert.True(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
||||||
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
||||||
|
|
||||||
// We saw traffic, should no longer be pending deletion
|
// We saw traffic, should no longer be pending deletion
|
||||||
nc.In(hostinfo)
|
nc.In(hostinfo)
|
||||||
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
||||||
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
||||||
}
|
}
|
||||||
@@ -329,31 +326,31 @@ func Test_NewConnectionManager_DisconnectInactive(t *testing.T) {
|
|||||||
// Do a traffic check tick, in and out should be cleared but should not be pending deletion
|
// Do a traffic check tick, in and out should be cleared but should not be pending deletion
|
||||||
nc.Out(hostinfo)
|
nc.Out(hostinfo)
|
||||||
nc.In(hostinfo)
|
nc.In(hostinfo)
|
||||||
assert.True(t, hostinfo.sentSinceCheck())
|
assert.True(t, hostinfo.out.Load())
|
||||||
assert.True(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.True(t, hostinfo.in.Load())
|
||||||
|
|
||||||
now := time.Now()
|
now := time.Now()
|
||||||
decision, _, _ := nc.makeTrafficDecision(hostinfo.localIndexId, now)
|
decision, _, _ := nc.makeTrafficDecision(hostinfo.localIndexId, now)
|
||||||
assert.Equal(t, tryRehandshake, decision)
|
assert.Equal(t, tryRehandshake, decision)
|
||||||
assert.Equal(t, now, hostinfo.lastUsed)
|
assert.Equal(t, now, hostinfo.lastUsed)
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
|
|
||||||
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*5))
|
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*5))
|
||||||
assert.Equal(t, doNothing, decision)
|
assert.Equal(t, doNothing, decision)
|
||||||
assert.Equal(t, now, hostinfo.lastUsed)
|
assert.Equal(t, now, hostinfo.lastUsed)
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
|
|
||||||
// Do another traffic check tick, should still not be pending deletion
|
// Do another traffic check tick, should still not be pending deletion
|
||||||
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*10))
|
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Second*10))
|
||||||
assert.Equal(t, doNothing, decision)
|
assert.Equal(t, doNothing, decision)
|
||||||
assert.Equal(t, now, hostinfo.lastUsed)
|
assert.Equal(t, now, hostinfo.lastUsed)
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
||||||
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
||||||
|
|
||||||
@@ -361,9 +358,9 @@ func Test_NewConnectionManager_DisconnectInactive(t *testing.T) {
|
|||||||
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Minute*10))
|
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, now.Add(time.Minute*10))
|
||||||
assert.Equal(t, closeTunnel, decision)
|
assert.Equal(t, closeTunnel, decision)
|
||||||
assert.Equal(t, now, hostinfo.lastUsed)
|
assert.Equal(t, now, hostinfo.lastUsed)
|
||||||
assert.False(t, hostinfo.isPendingDeletion())
|
assert.False(t, hostinfo.pendingDeletion.Load())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
assert.False(t, hostinfo.in.Load())
|
||||||
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
assert.Contains(t, nc.hostMap.Indexes, hostinfo.localIndexId)
|
||||||
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
assert.Contains(t, nc.hostMap.Hosts, hostinfo.vpnAddrs[0])
|
||||||
}
|
}
|
||||||
|
|||||||
+6
-19
@@ -14,7 +14,7 @@ import (
|
|||||||
)
|
)
|
||||||
|
|
||||||
const (
|
const (
|
||||||
ReplayWindow = 8192
|
ReplayWindow = 1024
|
||||||
|
|
||||||
// RehandshakeAfterMessages rolls keys inside the AES-GCM data-volume margin (~2^-36 advantage at 64KB frames).
|
// RehandshakeAfterMessages rolls keys inside the AES-GCM data-volume margin (~2^-36 advantage at 64KB frames).
|
||||||
RehandshakeAfterMessages = uint64(1) << 34
|
RehandshakeAfterMessages = uint64(1) << 34
|
||||||
@@ -26,14 +26,6 @@ const (
|
|||||||
// RehandshakeAfterMessages must stay below RejectAfterMessages so tunnels roll before the hard send stop.
|
// RehandshakeAfterMessages must stay below RejectAfterMessages so tunnels roll before the hard send stop.
|
||||||
const _ = RejectAfterMessages - RehandshakeAfterMessages
|
const _ = RejectAfterMessages - RehandshakeAfterMessages
|
||||||
|
|
||||||
// sessionEpoch hands out a receiver-local ordinal to every ConnectionState at creation. The RX
|
|
||||||
// staging sort (overlay/batch) orders packets by (epoch, message counter). A re-handshake never
|
|
||||||
// rekeys an existing tunnel; it brings up a new hostinfo and ConnectionState with a counter space
|
|
||||||
// starting near zero, while the old tunnel keeps decrypting until torn down. During that cutover
|
|
||||||
// one flush batch can hold packets from both tunnels, and the epoch keeps the old tunnel's
|
|
||||||
// packets sorted first.
|
|
||||||
var sessionEpoch atomic.Uint64
|
|
||||||
|
|
||||||
type ConnectionState struct {
|
type ConnectionState struct {
|
||||||
eKey noiseutil.CipherState
|
eKey noiseutil.CipherState
|
||||||
dKey noiseutil.CipherState
|
dKey noiseutil.CipherState
|
||||||
@@ -44,8 +36,6 @@ type ConnectionState struct {
|
|||||||
window *Bits
|
window *Bits
|
||||||
decryptLock sync.Mutex
|
decryptLock sync.Mutex
|
||||||
writeLock sync.Mutex
|
writeLock sync.Mutex
|
||||||
// epoch is this session's sessionEpoch ordinal. Immutable after creation.
|
|
||||||
epoch uint64
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// newConnectionStateFromResult builds a fully-populated ConnectionState from a
|
// newConnectionStateFromResult builds a fully-populated ConnectionState from a
|
||||||
@@ -65,7 +55,6 @@ func newConnectionStateFromResult(r *handshake.Result) (*ConnectionState, error)
|
|||||||
eKey: noiseutil.NewCipherState(r.EKey, r.Cipher),
|
eKey: noiseutil.NewCipherState(r.EKey, r.Cipher),
|
||||||
dKey: noiseutil.NewCipherState(r.DKey, r.Cipher),
|
dKey: noiseutil.NewCipherState(r.DKey, r.Cipher),
|
||||||
window: NewBits(ReplayWindow),
|
window: NewBits(ReplayWindow),
|
||||||
epoch: sessionEpoch.Add(1),
|
|
||||||
}
|
}
|
||||||
ci.messageCounter.Add(r.MessageIndex)
|
ci.messageCounter.Add(r.MessageIndex)
|
||||||
for i := uint64(1); i <= r.MessageIndex; i++ {
|
for i := uint64(1); i <= r.MessageIndex; i++ {
|
||||||
@@ -96,7 +85,8 @@ func (cs *ConnectionState) Curve() cert.Curve {
|
|||||||
return cs.myCert.Curve()
|
return cs.myCert.Curve()
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, packet []byte, nb []byte) ([]byte, error) {
|
func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, out []byte, packet []byte, nb []byte) ([]byte, error) {
|
||||||
|
var err error
|
||||||
cs.decryptLock.Lock()
|
cs.decryptLock.Lock()
|
||||||
result := cs.window.Check(l, messageCounter)
|
result := cs.window.Check(l, messageCounter)
|
||||||
cs.decryptLock.Unlock()
|
cs.decryptLock.Unlock()
|
||||||
@@ -104,7 +94,7 @@ func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, packet
|
|||||||
return nil, ErrAlreadySeen
|
return nil, ErrAlreadySeen
|
||||||
}
|
}
|
||||||
|
|
||||||
out, err := cs.dKey.DecryptDanger(packet[header.Len:header.Len], packet[:header.Len], packet[header.Len:], messageCounter, nb)
|
out, err = cs.dKey.DecryptDanger(out, packet[:header.Len], packet[header.Len:], messageCounter, nb)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
@@ -118,6 +108,7 @@ func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, packet
|
|||||||
return out, nil
|
return out, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// VerifyRelay verifies AEAD protected (but not encrypted) relay frames. packet must be length-checked by the caller.
|
||||||
func (cs *ConnectionState) VerifyRelay(l *slog.Logger, messageCounter uint64, packet []byte, nb []byte) error {
|
func (cs *ConnectionState) VerifyRelay(l *slog.Logger, messageCounter uint64, packet []byte, nb []byte) error {
|
||||||
cs.decryptLock.Lock()
|
cs.decryptLock.Lock()
|
||||||
result := cs.window.Check(l, messageCounter)
|
result := cs.window.Check(l, messageCounter)
|
||||||
@@ -126,11 +117,6 @@ func (cs *ConnectionState) VerifyRelay(l *slog.Logger, messageCounter uint64, pa
|
|||||||
return ErrAlreadySeen
|
return ErrAlreadySeen
|
||||||
}
|
}
|
||||||
|
|
||||||
// The entire body is sent as AD, not encrypted.
|
|
||||||
// The packet consists of a 16-byte parsed Nebula header, Associated Data-protected payload, and a trailing 16-byte AEAD signature value.
|
|
||||||
// The packet is guaranteed to be at least 16 bytes at this point, b/c it got past the h.Parse() call above. If it's
|
|
||||||
// otherwise malformed (meaning, there is no trailing 16 byte AEAD value), then this will result in at worst a 0-length slice
|
|
||||||
// which will gracefully fail in the DecryptDanger call.
|
|
||||||
signedPayload := packet[:len(packet)-cs.dKey.Overhead()]
|
signedPayload := packet[:len(packet)-cs.dKey.Overhead()]
|
||||||
signatureValue := packet[len(packet)-cs.dKey.Overhead():]
|
signatureValue := packet[len(packet)-cs.dKey.Overhead():]
|
||||||
_, err := cs.dKey.DecryptDanger(nil, signedPayload, signatureValue, messageCounter, nb)
|
_, err := cs.dKey.DecryptDanger(nil, signedPayload, signatureValue, messageCounter, nb)
|
||||||
@@ -144,5 +130,6 @@ func (cs *ConnectionState) VerifyRelay(l *slog.Logger, messageCounter uint64, pa
|
|||||||
if !result {
|
if !result {
|
||||||
return ErrAlreadySeen
|
return ErrAlreadySeen
|
||||||
}
|
}
|
||||||
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
+2
-148
@@ -2,8 +2,6 @@ package nebula
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"strconv"
|
|
||||||
"sync"
|
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
@@ -13,9 +11,7 @@ import (
|
|||||||
ct "github.com/slackhq/nebula/cert_test"
|
ct "github.com/slackhq/nebula/cert_test"
|
||||||
"github.com/slackhq/nebula/handshake"
|
"github.com/slackhq/nebula/handshake"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/overlay"
|
|
||||||
"github.com/slackhq/nebula/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/slackhq/nebula/udp"
|
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
)
|
)
|
||||||
@@ -100,7 +96,7 @@ func TestConnectionState_NextMessageCounter(t *testing.T) {
|
|||||||
assert.Equal(t, RejectAfterMessages, cs.messageCounter.Load())
|
assert.Equal(t, RejectAfterMessages, cs.messageCounter.Load())
|
||||||
|
|
||||||
// Continued send attempts stay refused and the counter never wraps
|
// Continued send attempts stay refused and the counter never wraps
|
||||||
for range 10 {
|
for i := 0; i < 10; i++ {
|
||||||
_, ok = cs.NextMessageCounter()
|
_, ok = cs.NextMessageCounter()
|
||||||
assert.False(t, ok)
|
assert.False(t, ok)
|
||||||
}
|
}
|
||||||
@@ -121,149 +117,7 @@ func TestSendNoMetricsDropsExhausted(t *testing.T) {
|
|||||||
|
|
||||||
// The crossing send is refused: it records an exhaustion drop and never reaches connectionManager.Out.
|
// The crossing send is refused: it records an exhaustion drop and never reaches connectionManager.Out.
|
||||||
assert.Equal(t, int64(1), f.messageMetrics.txExhausted.Count())
|
assert.Equal(t, int64(1), f.messageMetrics.txExhausted.Count())
|
||||||
assert.False(t, hostinfo.sentSinceCheck())
|
assert.False(t, hostinfo.out.Load())
|
||||||
}
|
|
||||||
|
|
||||||
// TestSendNoMetricsCloseTunnelKeepsRebindEpoch pins that a closing tunnel does not consume a rebind, a later
|
|
||||||
// packet on a re-established tunnel still needs that edge to trigger the far-side punch.
|
|
||||||
func TestSendNoMetricsCloseTunnelKeepsRebindEpoch(t *testing.T) {
|
|
||||||
initR, _ := runTestHandshake(t)
|
|
||||||
ci, err := newConnectionStateFromResult(initR)
|
|
||||||
require.NoError(t, err)
|
|
||||||
|
|
||||||
f := &Interface{
|
|
||||||
l: test.NewLogger(),
|
|
||||||
messageMetrics: &MessageMetrics{txExhausted: metrics.NewCounter()},
|
|
||||||
writers: []udp.Conn{udp.NoopConn{}},
|
|
||||||
connectionManager: &connectionManager{},
|
|
||||||
}
|
|
||||||
hostinfo := &HostInfo{vpnAddrs: []netip.Addr{netip.MustParseAddr("10.0.0.1")}, ConnectionState: ci}
|
|
||||||
|
|
||||||
// Tunnel is on epoch 0, then we rebind.
|
|
||||||
hostinfo.markOut(0)
|
|
||||||
f.rebindEpoch.Add(1)
|
|
||||||
|
|
||||||
remote := netip.MustParseAddrPort("10.0.0.2:4242")
|
|
||||||
f.sendNoMetrics(header.CloseTunnel, 0, ci, hostinfo, remote, []byte{}, make([]byte, 12), make([]byte, mtu), 0)
|
|
||||||
|
|
||||||
// markOut at the new epoch still reports the move, so the edge was preserved.
|
|
||||||
assert.True(t, hostinfo.markOut(1), "a CloseTunnel send must not consume the rebind epoch")
|
|
||||||
}
|
|
||||||
|
|
||||||
// capturingConn is a udp.Conn that records every WriteTo.
|
|
||||||
type capturingConn struct {
|
|
||||||
udp.NoopConn
|
|
||||||
writes [][]byte
|
|
||||||
addrs []netip.AddrPort
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *capturingConn) WriteTo(b []byte, addr netip.AddrPort) error {
|
|
||||||
c.writes = append(c.writes, append([]byte(nil), b...))
|
|
||||||
c.addrs = append(c.addrs, addr)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestSendNoMetricsViaRelay sends through a relay from the mtu sized buffer the cached packet flush uses. Payloads up
|
|
||||||
// to overlay.MaxMTU go out intact, anything bigger is dropped rather than outgrowing the buffer, which once panicked.
|
|
||||||
func TestSendNoMetricsViaRelay(t *testing.T) {
|
|
||||||
tests := []struct {
|
|
||||||
n int
|
|
||||||
sent bool
|
|
||||||
}{
|
|
||||||
{0, true},
|
|
||||||
{1300, true},
|
|
||||||
{overlay.MaxMTU, true},
|
|
||||||
{overlay.MaxMTU + 1, false}, // too big for the relay's tag
|
|
||||||
{mtu - 47, false}, // too big for the inner tag, this panicked
|
|
||||||
{9000, false}, // a full packet at tun.mtu 9000
|
|
||||||
}
|
|
||||||
for _, tt := range tests {
|
|
||||||
t.Run(strconv.Itoa(tt.n), func(t *testing.T) {
|
|
||||||
// One tunnel to the target, carried end to end, and one to the relay that wraps it
|
|
||||||
targetInit, targetResp := runTestHandshake(t)
|
|
||||||
relayInit, relayResp := runTestHandshake(t)
|
|
||||||
ci, err := newConnectionStateFromResult(targetInit)
|
|
||||||
require.NoError(t, err)
|
|
||||||
relayCI, err := newConnectionStateFromResult(relayInit)
|
|
||||||
require.NoError(t, err)
|
|
||||||
|
|
||||||
targetAddr := netip.MustParseAddr("10.0.0.2")
|
|
||||||
relayAddr := netip.MustParseAddr("10.0.0.3")
|
|
||||||
relayRemote := netip.MustParseAddrPort("192.0.2.1:4242")
|
|
||||||
|
|
||||||
relay := &Relay{Type: TerminalType, State: Established, LocalIndex: 5, RemoteIndex: 6, PeerAddr: targetAddr}
|
|
||||||
relayHI := &HostInfo{
|
|
||||||
vpnAddrs: []netip.Addr{relayAddr},
|
|
||||||
ConnectionState: relayCI,
|
|
||||||
relayState: RelayState{
|
|
||||||
relayForByAddr: map[netip.Addr]*Relay{targetAddr: relay},
|
|
||||||
relayForByIdx: map[uint32]*Relay{relay.LocalIndex: relay},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
relayHI.remote.Store(&relayRemote)
|
|
||||||
|
|
||||||
// No remote of its own, so the send has to go via the relay
|
|
||||||
hostinfo := &HostInfo{
|
|
||||||
vpnAddrs: []netip.Addr{targetAddr},
|
|
||||||
ConnectionState: ci,
|
|
||||||
remoteIndexId: 7,
|
|
||||||
relayState: RelayState{
|
|
||||||
relays: []netip.Addr{relayAddr},
|
|
||||||
relayForByAddr: map[netip.Addr]*Relay{},
|
|
||||||
relayForByIdx: map[uint32]*Relay{},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
l := test.NewLogger()
|
|
||||||
hm := newHostMap(l)
|
|
||||||
hm.Hosts[relayAddr] = relayHI
|
|
||||||
conn := &capturingConn{}
|
|
||||||
f := &Interface{
|
|
||||||
l: l,
|
|
||||||
hostMap: hm,
|
|
||||||
messageMetrics: &MessageMetrics{txExhausted: metrics.NewCounter()},
|
|
||||||
writers: []udp.Conn{conn},
|
|
||||||
}
|
|
||||||
f.connectionManager = &connectionManager{intf: f, relayUsed: map[uint32]struct{}{}, relayUsedLock: &sync.RWMutex{}}
|
|
||||||
|
|
||||||
payload := make([]byte, tt.n)
|
|
||||||
for i := range payload {
|
|
||||||
payload[i] = byte(i)
|
|
||||||
}
|
|
||||||
counter := ci.messageCounter.Load()
|
|
||||||
f.sendNoMetrics(header.Message, 0, ci, hostinfo, netip.AddrPort{}, payload, make([]byte, 12), make([]byte, mtu), 0)
|
|
||||||
|
|
||||||
if !tt.sent {
|
|
||||||
assert.Empty(t, conn.writes)
|
|
||||||
assert.Equal(t, counter, ci.messageCounter.Load(), "a dropped packet must not spend a counter")
|
|
||||||
return
|
|
||||||
}
|
|
||||||
require.Len(t, conn.writes, 1)
|
|
||||||
assert.Equal(t, relayRemote, conn.addrs[0])
|
|
||||||
pkt := conn.writes[0]
|
|
||||||
|
|
||||||
// The relay authenticates the whole packet under its own header
|
|
||||||
outer := &header.H{}
|
|
||||||
require.NoError(t, outer.Parse(pkt))
|
|
||||||
assert.Equal(t, header.MessageRelay, outer.Subtype)
|
|
||||||
assert.Equal(t, relay.RemoteIndex, outer.RemoteIndex)
|
|
||||||
relayPeer, err := newConnectionStateFromResult(relayResp)
|
|
||||||
require.NoError(t, err)
|
|
||||||
require.NoError(t, relayPeer.VerifyRelay(l, outer.MessageCounter, pkt, make([]byte, 12)))
|
|
||||||
|
|
||||||
// Inside it, the target decrypts the end to end packet back to the payload
|
|
||||||
inner := pkt[header.Len : len(pkt)-relayPeer.dKey.Overhead()]
|
|
||||||
h := &header.H{}
|
|
||||||
require.NoError(t, h.Parse(inner))
|
|
||||||
assert.Equal(t, header.Message, h.Type)
|
|
||||||
assert.Equal(t, hostinfo.remoteIndexId, h.RemoteIndex)
|
|
||||||
targetPeer, err := newConnectionStateFromResult(targetResp)
|
|
||||||
require.NoError(t, err)
|
|
||||||
got, err := targetPeer.Decrypt(l, h.MessageCounter, inner, make([]byte, 12))
|
|
||||||
require.NoError(t, err)
|
|
||||||
assert.Equal(t, payload, got)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestNewConnectionStateFromResult(t *testing.T) {
|
func TestNewConnectionStateFromResult(t *testing.T) {
|
||||||
|
|||||||
+2
-2
@@ -115,7 +115,7 @@ func (c *Control) Start() error {
|
|||||||
c.lighthouseStart()
|
c.lighthouseStart()
|
||||||
}
|
}
|
||||||
|
|
||||||
c.f.triggerShutdown = func() { go c.Stop() }
|
c.f.triggerShutdown = c.Stop
|
||||||
|
|
||||||
// Start reading packets.
|
// Start reading packets.
|
||||||
c.f.run()
|
c.f.run()
|
||||||
@@ -212,7 +212,7 @@ func (c *Control) RebindUDPServer() {
|
|||||||
c.f.lightHouse.SendUpdate()
|
c.f.lightHouse.SendUpdate()
|
||||||
|
|
||||||
// Let the main interface know that we rebound so that underlying tunnels know to trigger punches from their remotes
|
// Let the main interface know that we rebound so that underlying tunnels know to trigger punches from their remotes
|
||||||
c.f.rebindEpoch.Add(1)
|
c.f.rebindCount++
|
||||||
}
|
}
|
||||||
|
|
||||||
// ListHostmapHosts returns details about the actual or pending (handshaking) hostmap by vpn ip
|
// ListHostmapHosts returns details about the actual or pending (handshaking) hostmap by vpn ip
|
||||||
|
|||||||
+18
-35
@@ -11,8 +11,6 @@ import (
|
|||||||
|
|
||||||
"github.com/gaissmai/bart"
|
"github.com/gaissmai/bart"
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/overlay/batch"
|
|
||||||
"github.com/slackhq/nebula/overlay/tio"
|
|
||||||
"github.com/slackhq/nebula/routing"
|
"github.com/slackhq/nebula/routing"
|
||||||
"github.com/slackhq/nebula/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
@@ -32,9 +30,9 @@ func newFakeDevice() *fakeDevice {
|
|||||||
|
|
||||||
// Read blocks until Close like a real tun with no traffic, then reports EOF
|
// Read blocks until Close like a real tun with no traffic, then reports EOF
|
||||||
// the same way a closed device does
|
// the same way a closed device does
|
||||||
func (d *fakeDevice) Read() ([]tio.Packet, error) {
|
func (d *fakeDevice) Read(p []byte) (int, error) {
|
||||||
<-d.closedCh
|
<-d.closedCh
|
||||||
return nil, io.EOF
|
return 0, io.EOF
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *fakeDevice) Write(p []byte) (int, error) { return len(p), nil }
|
func (d *fakeDevice) Write(p []byte) (int, error) { return len(p), nil }
|
||||||
@@ -51,8 +49,10 @@ func (d *fakeDevice) Activate() error { return nil }
|
|||||||
func (d *fakeDevice) Networks() []netip.Prefix { return nil }
|
func (d *fakeDevice) Networks() []netip.Prefix { return nil }
|
||||||
func (d *fakeDevice) Name() string { return "fake" }
|
func (d *fakeDevice) Name() string { return "fake" }
|
||||||
func (d *fakeDevice) RoutesFor(netip.Addr) routing.Gateways { return nil }
|
func (d *fakeDevice) RoutesFor(netip.Addr) routing.Gateways { return nil }
|
||||||
|
func (d *fakeDevice) SupportsMultiqueue() bool { return false }
|
||||||
func (d *fakeDevice) Queues(int) ([]tio.Queue, error) { return []tio.Queue{d}, nil }
|
func (d *fakeDevice) NewMultiQueueReader() (io.ReadWriteCloser, error) {
|
||||||
|
return nil, errors.New("unsupported")
|
||||||
|
}
|
||||||
|
|
||||||
// newReadyControl hand-builds the minimum Control that Main would have
|
// newReadyControl hand-builds the minimum Control that Main would have
|
||||||
// produced right before Start, including the construction token NewInterface
|
// produced right before Start, including the construction token NewInterface
|
||||||
@@ -78,7 +78,7 @@ func newReadyControl(t *testing.T) (*Control, *fakeDevice, *fakeConn) {
|
|||||||
inside: dev,
|
inside: dev,
|
||||||
outside: conn,
|
outside: conn,
|
||||||
writers: []udp.Conn{conn},
|
writers: []udp.Conn{conn},
|
||||||
batchers: make([]*batch.MultiCoalescer, 1),
|
readers: make([]io.ReadWriteCloser, 1),
|
||||||
routines: 1,
|
routines: 1,
|
||||||
hostMap: newHostMap(l),
|
hostMap: newHostMap(l),
|
||||||
lightHouse: lh,
|
lightHouse: lh,
|
||||||
@@ -109,8 +109,7 @@ func TestControl_StopBeforeStart(t *testing.T) {
|
|||||||
require.NoError(t, c.Wait())
|
require.NoError(t, c.Wait())
|
||||||
|
|
||||||
// A stopped control can never be started
|
// A stopped control can never be started
|
||||||
err := c.Start()
|
require.ErrorIs(t, c.Start(), ErrAlreadyStopped)
|
||||||
require.ErrorIs(t, err, ErrAlreadyStopped)
|
|
||||||
|
|
||||||
// A second Stop is a harmless no-op
|
// A second Stop is a harmless no-op
|
||||||
c.Stop()
|
c.Stop()
|
||||||
@@ -146,11 +145,8 @@ type fakeConn struct {
|
|||||||
|
|
||||||
func (c *fakeConn) Rebind() error { c.rebinds++; return nil }
|
func (c *fakeConn) Rebind() error { c.rebinds++; return nil }
|
||||||
func (c *fakeConn) LocalAddr() (netip.AddrPort, error) { return netip.AddrPort{}, nil }
|
func (c *fakeConn) LocalAddr() (netip.AddrPort, error) { return netip.AddrPort{}, nil }
|
||||||
func (c *fakeConn) ListenOut(_ udp.EncReader, _ func()) error { return nil }
|
func (c *fakeConn) ListenOut(_ udp.EncReader) error { return nil }
|
||||||
func (c *fakeConn) WriteTo(_ []byte, _ netip.AddrPort) error { return nil }
|
func (c *fakeConn) WriteTo(_ []byte, _ netip.AddrPort) error { return nil }
|
||||||
func (c *fakeConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) {
|
|
||||||
return len(bufs), nil
|
|
||||||
}
|
|
||||||
func (c *fakeConn) ReloadConfig(_ *config.C) {}
|
func (c *fakeConn) ReloadConfig(_ *config.C) {}
|
||||||
func (c *fakeConn) SupportsMultipleReaders() bool { return true }
|
func (c *fakeConn) SupportsMultipleReaders() bool { return true }
|
||||||
func (c *fakeConn) Close() error { c.closed = true; return nil }
|
func (c *fakeConn) Close() error { c.closed = true; return nil }
|
||||||
@@ -159,14 +155,7 @@ type multiqueueDevice struct {
|
|||||||
*fakeDevice
|
*fakeDevice
|
||||||
}
|
}
|
||||||
|
|
||||||
// Queues claims multiqueue support but fails to open the second queue,
|
func (d *multiqueueDevice) SupportsMultiqueue() bool { return true }
|
||||||
// exercising the activation error path.
|
|
||||||
func (d *multiqueueDevice) Queues(n int) ([]tio.Queue, error) {
|
|
||||||
if n > 1 {
|
|
||||||
return nil, errors.New("second queue failed to open")
|
|
||||||
}
|
|
||||||
return d.fakeDevice.Queues(n)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestControl_StartMultiqueueFailureReleases(t *testing.T) {
|
func TestControl_StartMultiqueueFailureReleases(t *testing.T) {
|
||||||
dev := &multiqueueDevice{fakeDevice: newFakeDevice()}
|
dev := &multiqueueDevice{fakeDevice: newFakeDevice()}
|
||||||
@@ -177,7 +166,7 @@ func TestControl_StartMultiqueueFailureReleases(t *testing.T) {
|
|||||||
inside: dev,
|
inside: dev,
|
||||||
outside: conn,
|
outside: conn,
|
||||||
writers: []udp.Conn{conn},
|
writers: []udp.Conn{conn},
|
||||||
batchers: make([]*batch.MultiCoalescer, 2),
|
readers: make([]io.ReadWriteCloser, 2),
|
||||||
routines: 2,
|
routines: 2,
|
||||||
l: test.NewLogger(),
|
l: test.NewLogger(),
|
||||||
}
|
}
|
||||||
@@ -192,8 +181,7 @@ func TestControl_StartMultiqueueFailureReleases(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
// The second reader fails to open, everything must be released
|
// The second reader fails to open, everything must be released
|
||||||
err := c.Start()
|
require.Error(t, c.Start())
|
||||||
require.Error(t, err)
|
|
||||||
assert.Equal(t, StateStopped, c.State())
|
assert.Equal(t, StateStopped, c.State())
|
||||||
assert.True(t, dev.closed, "the tun device should have been closed")
|
assert.True(t, dev.closed, "the tun device should have been closed")
|
||||||
assert.True(t, conn.closed, "the udp socket should have been closed")
|
assert.True(t, conn.closed, "the udp socket should have been closed")
|
||||||
@@ -247,7 +235,7 @@ func TestControl_ConcurrentStopAndStart(t *testing.T) {
|
|||||||
c, _, _ := newReadyControl(t)
|
c, _, _ := newReadyControl(t)
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
var wg sync.WaitGroup
|
||||||
for range 2 {
|
for i := 0; i < 2; i++ {
|
||||||
wg.Go(func() { c.Stop() })
|
wg.Go(func() { c.Stop() })
|
||||||
}
|
}
|
||||||
wg.Go(func() { _ = c.Start() })
|
wg.Go(func() { _ = c.Start() })
|
||||||
@@ -263,18 +251,15 @@ func TestControl_ConcurrentStopAndStart(t *testing.T) {
|
|||||||
// panic and Wait must observe the final state
|
// panic and Wait must observe the final state
|
||||||
require.NoError(t, c.Wait())
|
require.NoError(t, c.Wait())
|
||||||
assert.Equal(t, StateStopped, c.State())
|
assert.Equal(t, StateStopped, c.State())
|
||||||
err := c.Start()
|
require.ErrorIs(t, c.Start(), ErrAlreadyStopped)
|
||||||
require.ErrorIs(t, err, ErrAlreadyStopped)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestControl_StartStopLifecycle(t *testing.T) {
|
func TestControl_StartStopLifecycle(t *testing.T) {
|
||||||
c, dev, conn := newReadyControl(t)
|
c, dev, conn := newReadyControl(t)
|
||||||
|
|
||||||
err := c.Start()
|
require.NoError(t, c.Start())
|
||||||
require.NoError(t, err)
|
|
||||||
assert.Equal(t, StateStarted, c.State())
|
assert.Equal(t, StateStarted, c.State())
|
||||||
err = c.Start()
|
require.ErrorIs(t, c.Start(), ErrAlreadyStarted)
|
||||||
require.ErrorIs(t, err, ErrAlreadyStarted)
|
|
||||||
|
|
||||||
// Stop must unpark the reader blocked in the device and release everything
|
// Stop must unpark the reader blocked in the device and release everything
|
||||||
c.Stop()
|
c.Stop()
|
||||||
@@ -285,8 +270,7 @@ func TestControl_StartStopLifecycle(t *testing.T) {
|
|||||||
|
|
||||||
// The reader drained off a closed device, that is not a fatal error
|
// The reader drained off a closed device, that is not a fatal error
|
||||||
require.NoError(t, c.Wait())
|
require.NoError(t, c.Wait())
|
||||||
err = c.Start()
|
require.ErrorIs(t, c.Start(), ErrAlreadyStopped)
|
||||||
require.ErrorIs(t, err, ErrAlreadyStopped)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestControl_RebindIsGatedByState(t *testing.T) {
|
func TestControl_RebindIsGatedByState(t *testing.T) {
|
||||||
@@ -296,8 +280,7 @@ func TestControl_RebindIsGatedByState(t *testing.T) {
|
|||||||
c.RebindUDPServer()
|
c.RebindUDPServer()
|
||||||
assert.Equal(t, 0, conn.rebinds, "rebind before start must be a no-op")
|
assert.Equal(t, 0, conn.rebinds, "rebind before start must be a no-op")
|
||||||
|
|
||||||
err := c.Start()
|
require.NoError(t, c.Start())
|
||||||
require.NoError(t, err)
|
|
||||||
c.RebindUDPServer()
|
c.RebindUDPServer()
|
||||||
assert.Equal(t, 1, conn.rebinds, "rebind while started must reach the conn")
|
assert.Equal(t, 1, conn.rebinds, "rebind while started must reach the conn")
|
||||||
|
|
||||||
|
|||||||
@@ -123,16 +123,6 @@ func (c *Control) SetLocalAddrsFn(fn func(*LocalAllowList) []netip.Addr) {
|
|||||||
c.f.lightHouse.localAddrsFn = fn
|
c.f.lightHouse.localAddrsFn = fn
|
||||||
}
|
}
|
||||||
|
|
||||||
// GetRebindEpochFor returns the rebind epoch a tunnel last sent under, so a test can tell whether a send
|
|
||||||
// consumed the epoch edge without having to infer it from lighthouse traffic.
|
|
||||||
func (c *Control) GetRebindEpochFor(vpnAddr netip.Addr) (uint32, bool) {
|
|
||||||
h := c.f.hostMap.QueryVpnAddr(vpnAddr)
|
|
||||||
if h == nil {
|
|
||||||
return 0, false
|
|
||||||
}
|
|
||||||
return h.state.Load() >> stateEpochShift, true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *Control) KillPendingTunnel(vpnIp netip.Addr) bool {
|
func (c *Control) KillPendingTunnel(vpnIp netip.Addr) bool {
|
||||||
hostinfo := c.f.handshakeManager.QueryVpnAddr(vpnIp)
|
hostinfo := c.f.handshakeManager.QueryVpnAddr(vpnIp)
|
||||||
if hostinfo == nil {
|
if hostinfo == nil {
|
||||||
|
|||||||
@@ -1,75 +0,0 @@
|
|||||||
//go:build linux && !android && !e2e_testing
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"strconv"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/unix"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Avoid removes cpus from the affinity of every thread of the process, for use at startup. New threads inherit
|
|
||||||
// their parent's mask, so it repeats until a pass finds nothing left to change; a thread that exits meanwhile is
|
|
||||||
// skipped. Every mask is checked before any is changed. With apply false it only validates, for configuration tests.
|
|
||||||
// This affects the entire process, including other users of an embedded Nebula. Not wired up yet: tun.avoid_cpus
|
|
||||||
// only steers Default for now.
|
|
||||||
func Avoid(cpus []int, apply bool) error {
|
|
||||||
const capacity = int(unsafe.Sizeof(unix.CPUSet{})) * 8
|
|
||||||
for _, cpu := range cpus {
|
|
||||||
if cpu < 0 || cpu >= capacity {
|
|
||||||
return fmt.Errorf("CPU %d is out of range", cpu)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(cpus) == 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
for {
|
|
||||||
masks, err := avoidingMasks(cpus)
|
|
||||||
if err != nil || !apply || len(masks) == 0 {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
for tid, mask := range masks {
|
|
||||||
if err := unix.SchedSetaffinity(tid, &mask); err != nil && !errors.Is(err, unix.ESRCH) {
|
|
||||||
return fmt.Errorf("set thread %d affinity: %w", tid, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// avoidingMasks returns the mask without cpus of every thread whose mask has any of them.
|
|
||||||
func avoidingMasks(cpus []int) (map[int]unix.CPUSet, error) {
|
|
||||||
entries, err := os.ReadDir("/proc/self/task")
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
masks := make(map[int]unix.CPUSet, len(entries))
|
|
||||||
for _, entry := range entries {
|
|
||||||
tid, err := strconv.Atoi(entry.Name())
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
var mask unix.CPUSet
|
|
||||||
err = unix.SchedGetaffinity(tid, &mask)
|
|
||||||
if errors.Is(err, unix.ESRCH) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("read thread %d affinity: %w", tid, err)
|
|
||||||
}
|
|
||||||
next := mask
|
|
||||||
for _, cpu := range cpus {
|
|
||||||
next.Clear(cpu)
|
|
||||||
}
|
|
||||||
if next.Count() == 0 {
|
|
||||||
return nil, fmt.Errorf("avoid_cpus leaves thread %d with no allowed CPU", tid)
|
|
||||||
}
|
|
||||||
if next != mask {
|
|
||||||
masks[tid] = next
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return masks, nil
|
|
||||||
}
|
|
||||||
@@ -1,98 +0,0 @@
|
|||||||
//go:build linux && !android && !e2e_testing
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"os/exec"
|
|
||||||
"runtime"
|
|
||||||
"strconv"
|
|
||||||
"sync"
|
|
||||||
"testing"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/util"
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
"golang.org/x/sys/unix"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestAvoid changes the affinity of the whole process, so it runs in a child, leaving the test runner untouched.
|
|
||||||
func TestAvoid(t *testing.T) {
|
|
||||||
if os.Getenv("NEBULA_CPUPICK_AVOID_TEST") != "1" {
|
|
||||||
exe, err := os.Executable()
|
|
||||||
require.NoError(t, err)
|
|
||||||
cmd := exec.Command(exe, "-test.run=^TestAvoid$", "-test.v")
|
|
||||||
cmd.Env = append(os.Environ(), "NEBULA_CPUPICK_AVOID_TEST=1")
|
|
||||||
out, err := cmd.CombinedOutput()
|
|
||||||
require.NoError(t, err, "%s", out)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
allowed, err := util.AllowedCPUs()
|
|
||||||
require.NoError(t, err)
|
|
||||||
if len(allowed) < 2 {
|
|
||||||
t.Skip("requires at least two allowed CPUs")
|
|
||||||
}
|
|
||||||
cpu := allowed[0]
|
|
||||||
release := make(chan struct{})
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
// lockThreads occupies 8 OS threads until release, so the runtime has to start more
|
|
||||||
lockThreads := func() {
|
|
||||||
var ready sync.WaitGroup
|
|
||||||
for range 8 {
|
|
||||||
ready.Add(1)
|
|
||||||
wg.Go(func() {
|
|
||||||
runtime.LockOSThread()
|
|
||||||
ready.Done()
|
|
||||||
<-release
|
|
||||||
})
|
|
||||||
}
|
|
||||||
ready.Wait()
|
|
||||||
}
|
|
||||||
lockThreads()
|
|
||||||
|
|
||||||
require.NoError(t, Avoid([]int{cpu}, false))
|
|
||||||
after, err := util.AllowedCPUs()
|
|
||||||
require.NoError(t, err)
|
|
||||||
require.Equal(t, allowed, after, "configuration check must not mutate affinity")
|
|
||||||
require.Error(t, Avoid(allowed, true), "must reject an empty mask before applying")
|
|
||||||
require.NoError(t, Avoid([]int{cpu, cpu}, true))
|
|
||||||
requireAvoided(t, cpu, allowed)
|
|
||||||
// Existing threads stay locked while new ones inherit the restriction
|
|
||||||
lockThreads()
|
|
||||||
requireAvoided(t, cpu, allowed)
|
|
||||||
close(release)
|
|
||||||
wg.Wait()
|
|
||||||
}
|
|
||||||
|
|
||||||
// requireAvoided checks no thread may run on cpu, and every thread still may on some CPU of allowed only.
|
|
||||||
func requireAvoided(t *testing.T, cpu int, allowed []int) {
|
|
||||||
t.Helper()
|
|
||||||
entries, err := os.ReadDir("/proc/self/task")
|
|
||||||
require.NoError(t, err)
|
|
||||||
for _, entry := range entries {
|
|
||||||
tid, err := strconv.Atoi(entry.Name())
|
|
||||||
require.NoError(t, err)
|
|
||||||
var mask unix.CPUSet
|
|
||||||
err = unix.SchedGetaffinity(tid, &mask)
|
|
||||||
if err == unix.ESRCH {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
require.NoError(t, err)
|
|
||||||
require.False(t, mask.IsSet(cpu), "thread %d", tid)
|
|
||||||
require.Positive(t, mask.Count())
|
|
||||||
for id := range len(mask) * 64 {
|
|
||||||
if mask.IsSet(id) {
|
|
||||||
require.Contains(t, allowed, id, "must not widen the inherited mask")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestAvoidRange checks the bounds of unix.CPUSet, whose words are 32 bits wide on 32-bit platforms.
|
|
||||||
func TestAvoidRange(t *testing.T) {
|
|
||||||
capacity := int(unsafe.Sizeof(unix.CPUSet{})) * 8
|
|
||||||
require.NoError(t, Avoid([]int{capacity - 1}, false))
|
|
||||||
require.EqualError(t, Avoid([]int{capacity}, false), fmt.Sprintf("CPU %d is out of range", capacity))
|
|
||||||
require.EqualError(t, Avoid([]int{-1}, false), "CPU -1 is out of range")
|
|
||||||
}
|
|
||||||
@@ -1,8 +0,0 @@
|
|||||||
//go:build !linux || android || e2e_testing
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import "errors"
|
|
||||||
|
|
||||||
// Avoid is unsupported outside Linux: there is no thread affinity API to restrict.
|
|
||||||
func Avoid(_ []int, _ bool) error { return errors.ErrUnsupported }
|
|
||||||
@@ -1,198 +0,0 @@
|
|||||||
// Package cpupick chooses which CPUs the tun reader threads pin to when the
|
|
||||||
// operator has not chosen for us (tun.cpu_affinity). The stock spread —
|
|
||||||
// allowed[i] for routine i — has two failure modes this package exists to fix:
|
|
||||||
//
|
|
||||||
// - every co-located nebula starts its spread at allowed[0], so N instances
|
|
||||||
// on one box stack their readers onto the same cores, and allowed[0] is
|
|
||||||
// usually CPU 0, the core housekeeping and default IRQ affinity already
|
|
||||||
// favor;
|
|
||||||
// - on heterogeneous CPUs (ARM big.LITTLE, Intel P/E hybrids, AMD compact
|
|
||||||
// cores) low IDs are not necessarily fast cores, and pinning an encrypt
|
|
||||||
// thread to an efficiency core caps that queue's throughput.
|
|
||||||
//
|
|
||||||
// Default instead returns a preference-ordered pin list: the allowed set
|
|
||||||
// filtered to performance cores (when the platform distinguishes them and
|
|
||||||
// enough remain for every routine), confined to a single NUMA node and spread
|
|
||||||
// across distinct physical cores when the topology permits, CPU 0's physical
|
|
||||||
// core demoted to last resort, and the order rotated by a stable per-instance
|
|
||||||
// key so co-located instances spread instead of stacking.
|
|
||||||
//
|
|
||||||
// CPUs the operator asked to keep readers off (tun.avoid_cpus, typically the
|
|
||||||
// underlay NIC's receive IRQ CPUs) are removed from the allowed set before
|
|
||||||
// any of that, so no rule can bring one back.
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"log/slog"
|
|
||||||
"slices"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/util"
|
|
||||||
)
|
|
||||||
|
|
||||||
// topology is the slice of machine layout arrange consults: the NUMA node
|
|
||||||
// and the physical core behind each candidate CPU, plus which core CPU 0
|
|
||||||
// lives on (zeroCore, -1 when unknown — tracked separately because CPU 0's
|
|
||||||
// SMT sibling deserves demotion even when CPU 0 itself isn't a candidate).
|
|
||||||
// Probed from sysfs on Linux; flatTopology stands in when the platform can't
|
|
||||||
// say, which turns every topology rule into a no-op rather than a wrong
|
|
||||||
// answer.
|
|
||||||
type topology struct {
|
|
||||||
nodeOf map[int]int
|
|
||||||
coreOf map[int]int
|
|
||||||
zeroCore int
|
|
||||||
}
|
|
||||||
|
|
||||||
// flatTopology places every CPU on node 0 and on a physical core of its own.
|
|
||||||
func flatTopology(cpus []int) topology {
|
|
||||||
t := topology{
|
|
||||||
nodeOf: make(map[int]int, len(cpus)),
|
|
||||||
coreOf: make(map[int]int, len(cpus)),
|
|
||||||
zeroCore: -1,
|
|
||||||
}
|
|
||||||
for i, c := range cpus {
|
|
||||||
t.nodeOf[c] = 0
|
|
||||||
t.coreOf[c] = i
|
|
||||||
if c == 0 {
|
|
||||||
t.zeroCore = i
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return t
|
|
||||||
}
|
|
||||||
|
|
||||||
// Default computes the pin order for `routines` tun readers. key is any
|
|
||||||
// stable per-instance value; the bound UDP port is ideal — distinct across
|
|
||||||
// co-located instances, stable across restarts so benchmark runs stay
|
|
||||||
// comparable. avoid lists CPUs never to return, matched literally. Returns
|
|
||||||
// nil when there is nothing useful to say (no affinity support on this
|
|
||||||
// platform, lookup failure, avoid covering every allowed CPU); callers keep
|
|
||||||
// their existing fallback spread.
|
|
||||||
func Default(routines int, key uint64, avoid []int, l *slog.Logger) []int {
|
|
||||||
allowed, err := util.AllowedCPUs()
|
|
||||||
if err != nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
allowed = slices.DeleteFunc(allowed, func(c int) bool { return slices.Contains(avoid, c) })
|
|
||||||
if len(allowed) == 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
perf, signal := perfCPUs(allowed)
|
|
||||||
cands := pickCandidates(allowed, perf, routines)
|
|
||||||
if len(cands) == 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
if len(perf) < routines {
|
|
||||||
signal = ""
|
|
||||||
}
|
|
||||||
cpus := arrange(cands, readTopology(cands), routines, splitmix64(key))
|
|
||||||
if l != nil {
|
|
||||||
l.Info("chose default pin CPUs for tun readers",
|
|
||||||
"cpus", cpus[:min(routines, len(cpus))],
|
|
||||||
"perfSignal", signal,
|
|
||||||
"avoided", avoid)
|
|
||||||
}
|
|
||||||
return cpus
|
|
||||||
}
|
|
||||||
|
|
||||||
// pickCandidates applies the enough-for-everyone guard: a perf filter that
|
|
||||||
// leaves fewer candidates than routines is discarded — giving every reader
|
|
||||||
// its own (possibly slow) core beats stacking two readers on a fast one.
|
|
||||||
func pickCandidates(allowed, perf []int, routines int) []int {
|
|
||||||
if len(perf) < routines {
|
|
||||||
return allowed
|
|
||||||
}
|
|
||||||
return perf
|
|
||||||
}
|
|
||||||
|
|
||||||
// arrange turns the candidate set into the final pin order:
|
|
||||||
//
|
|
||||||
// 1. NUMA: when at least one node holds enough candidates for every
|
|
||||||
// routine, confine to one such node, chosen by the instance hash. The
|
|
||||||
// readers share hostmap and cipher state, so splitting one instance
|
|
||||||
// across nodes taxes every packet — and co-located instances that hash
|
|
||||||
// to different nodes stop competing entirely. When no node is big
|
|
||||||
// enough, span nodes rather than stack readers.
|
|
||||||
// 2. Rotate the preferred candidates by the hash so instances spread.
|
|
||||||
// 3. SMT: emit one thread per physical core before any of their siblings —
|
|
||||||
// two encrypt threads on one core split its execution units. Siblings
|
|
||||||
// still follow for the routines > cores case.
|
|
||||||
// 4. CPU 0's whole physical core goes last: housekeeping and default IRQ
|
|
||||||
// noise on CPU 0 bleeds into its SMT sibling too. Within that tail the
|
|
||||||
// sibling precedes CPU 0 itself, which only catches the bleed-through.
|
|
||||||
//
|
|
||||||
// The rotation happens before the SMT pass so each instance's one-per-core
|
|
||||||
// walk also starts at a different core, and CPU 0's core is excluded from
|
|
||||||
// the rotation so no hash value can put it back at the front.
|
|
||||||
func arrange(cands []int, topo topology, routines int, h uint64) []int {
|
|
||||||
byNode := map[int][]int{}
|
|
||||||
var nodes []int
|
|
||||||
for _, c := range cands {
|
|
||||||
n := topo.nodeOf[c]
|
|
||||||
if _, ok := byNode[n]; !ok {
|
|
||||||
nodes = append(nodes, n)
|
|
||||||
}
|
|
||||||
byNode[n] = append(byNode[n], c)
|
|
||||||
}
|
|
||||||
var eligible []int
|
|
||||||
for _, n := range nodes {
|
|
||||||
if len(byNode[n]) >= routines {
|
|
||||||
eligible = append(eligible, n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(eligible) > 0 {
|
|
||||||
cands = byNode[eligible[int(h%uint64(len(eligible)))]]
|
|
||||||
}
|
|
||||||
|
|
||||||
// Split off CPU 0's core: its siblings tail the list, CPU 0 tails them.
|
|
||||||
preferred := make([]int, 0, len(cands))
|
|
||||||
var zeroTail []int
|
|
||||||
hasZero := false
|
|
||||||
for _, c := range cands {
|
|
||||||
switch {
|
|
||||||
case c == 0:
|
|
||||||
hasZero = true
|
|
||||||
case topo.zeroCore >= 0 && topo.coreOf[c] == topo.zeroCore:
|
|
||||||
zeroTail = append(zeroTail, c)
|
|
||||||
default:
|
|
||||||
preferred = append(preferred, c)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if hasZero {
|
|
||||||
zeroTail = append(zeroTail, 0)
|
|
||||||
}
|
|
||||||
if len(preferred) == 0 {
|
|
||||||
return zeroTail // CPU 0's core is all we have
|
|
||||||
}
|
|
||||||
|
|
||||||
// The node pick consumed the low hash bits; rotate by the high ones so
|
|
||||||
// the two choices stay independent.
|
|
||||||
off := int((h >> 32) % uint64(len(preferred)))
|
|
||||||
rot := make([]int, 0, len(preferred))
|
|
||||||
rot = append(rot, preferred[off:]...)
|
|
||||||
rot = append(rot, preferred[:off]...)
|
|
||||||
|
|
||||||
seenCore := make(map[int]bool, len(rot))
|
|
||||||
out := make([]int, 0, len(cands))
|
|
||||||
var siblings []int
|
|
||||||
for _, c := range rot {
|
|
||||||
g := topo.coreOf[c]
|
|
||||||
if seenCore[g] {
|
|
||||||
siblings = append(siblings, c)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
seenCore[g] = true
|
|
||||||
out = append(out, c)
|
|
||||||
}
|
|
||||||
out = append(out, siblings...)
|
|
||||||
out = append(out, zeroTail...)
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
|
|
||||||
// splitmix64 decorrelates instance keys before the selection modulos: ports
|
|
||||||
// on one box often share spacing (4242/4243, or round steps like +1000) that
|
|
||||||
// raw key%len arithmetic would fold onto the same offset.
|
|
||||||
func splitmix64(x uint64) uint64 {
|
|
||||||
x += 0x9e3779b97f4a7c15
|
|
||||||
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9
|
|
||||||
x = (x ^ (x >> 27)) * 0x94d049bb133111eb
|
|
||||||
return x ^ (x >> 31)
|
|
||||||
}
|
|
||||||
@@ -1,171 +0,0 @@
|
|||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"slices"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
// pairTopo builds a topology where consecutive candidate pairs are SMT
|
|
||||||
// siblings: (cpus[0],cpus[1]) share a core, (cpus[2],cpus[3]) the next, ...
|
|
||||||
// All CPUs land on node 0.
|
|
||||||
func pairTopo(cpus []int) topology {
|
|
||||||
t := topology{
|
|
||||||
nodeOf: make(map[int]int, len(cpus)),
|
|
||||||
coreOf: make(map[int]int, len(cpus)),
|
|
||||||
zeroCore: -1,
|
|
||||||
}
|
|
||||||
for i, c := range cpus {
|
|
||||||
t.nodeOf[c] = 0
|
|
||||||
t.coreOf[c] = i / 2
|
|
||||||
if c == 0 {
|
|
||||||
t.zeroCore = i / 2
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return t
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeDemotesZeroForEveryKey(t *testing.T) {
|
|
||||||
candidates := []int{0, 1, 2, 3, 4, 5, 6, 7}
|
|
||||||
for key := range uint64(64) {
|
|
||||||
got := arrange(candidates, flatTopology(candidates), 4, splitmix64(key))
|
|
||||||
if len(got) != len(candidates) {
|
|
||||||
t.Fatalf("key %d: len=%d want %d", key, len(got), len(candidates))
|
|
||||||
}
|
|
||||||
if got[0] == 0 {
|
|
||||||
t.Errorf("key %d: CPU 0 at the front: %v", key, got)
|
|
||||||
}
|
|
||||||
if got[len(got)-1] != 0 {
|
|
||||||
t.Errorf("key %d: CPU 0 not demoted to last: %v", key, got)
|
|
||||||
}
|
|
||||||
sorted := slices.Clone(got)
|
|
||||||
slices.Sort(sorted)
|
|
||||||
if !slices.Equal(sorted, candidates) {
|
|
||||||
t.Errorf("key %d: not a permutation: %v", key, got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeDemotesZeroSiblings(t *testing.T) {
|
|
||||||
// Pairs (0,1),(2,3),(4,5),(6,7): CPU 0's core — 0 and its sibling 1 —
|
|
||||||
// must tail the list, sibling ahead of 0 itself.
|
|
||||||
candidates := []int{0, 1, 2, 3, 4, 5, 6, 7}
|
|
||||||
for key := range uint64(64) {
|
|
||||||
got := arrange(candidates, pairTopo(candidates), 2, splitmix64(key))
|
|
||||||
n := len(got)
|
|
||||||
if got[n-1] != 0 || got[n-2] != 1 {
|
|
||||||
t.Fatalf("key %d: tail = %v, want [... 1 0]", key, got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeZeroSiblingWithoutZero(t *testing.T) {
|
|
||||||
// CPU 0 excluded (cpuset) but its sibling 1 remains: the sibling still
|
|
||||||
// tails the list when the topology knows which core CPU 0 lives on.
|
|
||||||
candidates := []int{1, 2, 3, 4, 5}
|
|
||||||
topo := pairTopo([]int{0, 1, 2, 3, 4, 5})
|
|
||||||
got := arrange(candidates, topo, 2, splitmix64(7))
|
|
||||||
if got[len(got)-1] != 1 {
|
|
||||||
t.Errorf("CPU 0's sibling not demoted: %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeRotatesByKey(t *testing.T) {
|
|
||||||
candidates := []int{1, 2, 3, 4, 5, 6, 7, 8}
|
|
||||||
seen := map[int]bool{}
|
|
||||||
for key := range uint64(64) {
|
|
||||||
seen[arrange(candidates, flatTopology(candidates), 4, splitmix64(key))[0]] = true
|
|
||||||
}
|
|
||||||
// 64 hashed keys over 8 slots must hit more than one starting CPU, or
|
|
||||||
// co-located instances would all stack again.
|
|
||||||
if len(seen) < 2 {
|
|
||||||
t.Errorf("rotation never varied across keys: %v", seen)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeStableForSameKey(t *testing.T) {
|
|
||||||
candidates := []int{0, 2, 4, 6}
|
|
||||||
topo := flatTopology(candidates)
|
|
||||||
a := arrange(candidates, topo, 2, splitmix64(4242))
|
|
||||||
b := arrange(candidates, topo, 2, splitmix64(4242))
|
|
||||||
if !slices.Equal(a, b) {
|
|
||||||
t.Errorf("same key ordered differently: %v vs %v", a, b)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeZeroOnly(t *testing.T) {
|
|
||||||
if got := arrange([]int{0}, flatTopology([]int{0}), 1, splitmix64(7)); !slices.Equal(got, []int{0}) {
|
|
||||||
t.Errorf("sole CPU 0 must survive: %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeSMTSiblingsLast(t *testing.T) {
|
|
||||||
// Pairs (1,2),(3,4),(5,6),(7,8): the first four picks must cover four
|
|
||||||
// distinct physical cores before any sibling repeats.
|
|
||||||
candidates := []int{1, 2, 3, 4, 5, 6, 7, 8}
|
|
||||||
topo := pairTopo(candidates)
|
|
||||||
for key := range uint64(16) {
|
|
||||||
got := arrange(candidates, topo, 4, splitmix64(key))
|
|
||||||
seen := map[int]bool{}
|
|
||||||
for _, c := range got[:4] {
|
|
||||||
g := topo.coreOf[c]
|
|
||||||
if seen[g] {
|
|
||||||
t.Fatalf("key %d: sibling before all cores covered: %v", key, got)
|
|
||||||
}
|
|
||||||
seen[g] = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeNUMAConfinesToOneNode(t *testing.T) {
|
|
||||||
// Two nodes of four; both fit routines=3, so the result must sit
|
|
||||||
// entirely inside one of them, and the hash must pick both across keys.
|
|
||||||
candidates := []int{1, 2, 3, 4, 10, 11, 12, 13}
|
|
||||||
topo := flatTopology(candidates)
|
|
||||||
for _, c := range []int{10, 11, 12, 13} {
|
|
||||||
topo.nodeOf[c] = 1
|
|
||||||
}
|
|
||||||
nodesSeen := map[int]bool{}
|
|
||||||
for key := range uint64(32) {
|
|
||||||
got := arrange(candidates, topo, 3, splitmix64(key))
|
|
||||||
if len(got) != 4 {
|
|
||||||
t.Fatalf("key %d: not confined to one node: %v", key, got)
|
|
||||||
}
|
|
||||||
n := topo.nodeOf[got[0]]
|
|
||||||
for _, c := range got {
|
|
||||||
if topo.nodeOf[c] != n {
|
|
||||||
t.Fatalf("key %d: spans nodes: %v", key, got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
nodesSeen[n] = true
|
|
||||||
}
|
|
||||||
if len(nodesSeen) != 2 {
|
|
||||||
t.Errorf("hash never spread instances across nodes: %v", nodesSeen)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestArrangeNUMASpansWhenNoNodeFits(t *testing.T) {
|
|
||||||
candidates := []int{1, 2, 3, 4, 10, 11, 12, 13}
|
|
||||||
topo := flatTopology(candidates)
|
|
||||||
for _, c := range []int{10, 11, 12, 13} {
|
|
||||||
topo.nodeOf[c] = 1
|
|
||||||
}
|
|
||||||
got := arrange(candidates, topo, 6, splitmix64(1))
|
|
||||||
if len(got) != len(candidates) {
|
|
||||||
t.Errorf("undersized nodes must span, got %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPickCandidates(t *testing.T) {
|
|
||||||
allowed := []int{0, 1, 2, 3, 4, 5, 6, 7}
|
|
||||||
perf := []int{4, 5}
|
|
||||||
|
|
||||||
// Enough perf cores for every routine: only they are used.
|
|
||||||
if got := pickCandidates(allowed, perf, 2); !slices.Equal(got, perf) {
|
|
||||||
t.Errorf("perf filter not applied: %v", got)
|
|
||||||
}
|
|
||||||
// Perf filter too small for the routine count: discarded, everyone
|
|
||||||
// gets their own core from the full allowed set.
|
|
||||||
if got := pickCandidates(allowed, perf, 4); !slices.Equal(got, allowed) {
|
|
||||||
t.Errorf("undersized perf filter not discarded: %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,35 +0,0 @@
|
|||||||
//go:build linux && !android && !e2e_testing
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"slices"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/util"
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestDefaultSkipsAvoided(t *testing.T) {
|
|
||||||
allowed, err := util.AllowedCPUs()
|
|
||||||
require.NoError(t, err)
|
|
||||||
if len(allowed) < 2 {
|
|
||||||
t.Skip("requires at least two allowed CPUs")
|
|
||||||
}
|
|
||||||
avoid := allowed[:len(allowed)/2]
|
|
||||||
for key := range uint64(16) {
|
|
||||||
got := Default(len(allowed), key, avoid, nil)
|
|
||||||
require.NotEmpty(t, got)
|
|
||||||
for _, cpu := range got {
|
|
||||||
assert.NotContains(t, avoid, cpu, "key %d", key)
|
|
||||||
assert.Contains(t, allowed, cpu, "key %d", key)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
assert.Nil(t, Default(2, 0, allowed, nil), "avoiding everything leaves nothing to suggest")
|
|
||||||
|
|
||||||
// Without avoid every allowed CPU stays in play
|
|
||||||
got := Default(len(allowed), 0, nil, nil)
|
|
||||||
slices.Sort(got)
|
|
||||||
assert.Equal(t, allowed, got)
|
|
||||||
}
|
|
||||||
@@ -1,154 +0,0 @@
|
|||||||
//go:build linux
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// capacityKeepPct is the cpu_capacity admission threshold, relative to the
|
|
||||||
// fastest allowed core. LITTLE cores are normalized to ~250-400 of the big
|
|
||||||
// core's 1024 while mid cores sit at ~75%+, so half of max separates little
|
|
||||||
// from the rest without splitting prime from mid on three-tier parts.
|
|
||||||
const capacityKeepPct = 50
|
|
||||||
|
|
||||||
// freqKeepPct is the cpuinfo_max_freq admission threshold. Favored-core
|
|
||||||
// turbo skew is 2-4% and ARM mid-vs-prime ~12%, while E-cores, LITTLE
|
|
||||||
// cores, and AMD compact cores all sit >= 20% below their siblings' max.
|
|
||||||
const freqKeepPct = 85
|
|
||||||
|
|
||||||
// perfCPUs partitions allowed into the subset that are "performance" cores,
|
|
||||||
// consulting (in order of authority):
|
|
||||||
//
|
|
||||||
// 1. cpu_capacity — arch_topology's normalized per-CPU capacity, exposed on
|
|
||||||
// arm/arm64/riscv; the scheduler's own view of big vs LITTLE.
|
|
||||||
// 2. /sys/devices/cpu_core/cpus — the Intel hybrid P-core PMU mask, present
|
|
||||||
// only on P/E parts (x86 has no cpu_capacity) and naming P cores outright.
|
|
||||||
// 3. cpuinfo_max_freq — the cross-vendor fallback; catches AMD compact
|
|
||||||
// cores, which neither of the above covers.
|
|
||||||
//
|
|
||||||
// Returns allowed unchanged (signal "") when nothing distinguishes the
|
|
||||||
// cores: homogeneous parts, VMs without cpufreq, sysfs unavailable.
|
|
||||||
func perfCPUs(allowed []int) ([]int, string) {
|
|
||||||
return perfCPUsFrom("/sys/devices/system/cpu", "/sys/devices/cpu_core/cpus", allowed)
|
|
||||||
}
|
|
||||||
|
|
||||||
func perfCPUsFrom(cpuDir, intelCoreMask string, allowed []int) ([]int, string) {
|
|
||||||
if cpus, ok := byPerCPUValue(cpuDir, "cpu_capacity", allowed, capacityKeepPct); ok {
|
|
||||||
return cpus, "cpu_capacity"
|
|
||||||
}
|
|
||||||
if cpus, ok := byIntelCoreMask(intelCoreMask, allowed); ok {
|
|
||||||
return cpus, "intel_core_pmu"
|
|
||||||
}
|
|
||||||
if cpus, ok := byPerCPUValue(cpuDir, "cpufreq/cpuinfo_max_freq", allowed, freqKeepPct); ok {
|
|
||||||
return cpus, "max_freq"
|
|
||||||
}
|
|
||||||
return allowed, ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// byPerCPUValue keeps the allowed CPUs whose per-CPU sysfs value is at least
|
|
||||||
// keepPct percent of the maximum across allowed. Inconclusive (ok=false)
|
|
||||||
// when any CPU is missing the file or when every value is equal.
|
|
||||||
func byPerCPUValue(cpuDir, file string, allowed []int, keepPct int) ([]int, bool) {
|
|
||||||
vals := make([]int, len(allowed))
|
|
||||||
minV, maxV := 0, 0
|
|
||||||
for i, cpu := range allowed {
|
|
||||||
v, err := readIntFile(filepath.Join(cpuDir, fmt.Sprintf("cpu%d", cpu), file))
|
|
||||||
if err != nil {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
vals[i] = v
|
|
||||||
if i == 0 || v < minV {
|
|
||||||
minV = v
|
|
||||||
}
|
|
||||||
if v > maxV {
|
|
||||||
maxV = v
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if minV == maxV {
|
|
||||||
return nil, false // homogeneous by this signal; try the next one
|
|
||||||
}
|
|
||||||
keep := make([]int, 0, len(allowed))
|
|
||||||
for i, cpu := range allowed {
|
|
||||||
if vals[i]*100 >= maxV*keepPct {
|
|
||||||
keep = append(keep, cpu)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return keep, true
|
|
||||||
}
|
|
||||||
|
|
||||||
// byIntelCoreMask keeps the allowed CPUs named by the hybrid P-core PMU
|
|
||||||
// mask. Inconclusive when the file is absent (non-hybrid x86, other arches)
|
|
||||||
// or no allowed CPU is in the mask (the process was deliberately confined
|
|
||||||
// to E-cores; nothing useful to prefer within that).
|
|
||||||
func byIntelCoreMask(maskPath string, allowed []int) ([]int, bool) {
|
|
||||||
b, err := os.ReadFile(maskPath)
|
|
||||||
if err != nil {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
set, err := parseCPUList(strings.TrimSpace(string(b)))
|
|
||||||
if err != nil || len(set) == 0 {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
pcore := make(map[int]bool, len(set))
|
|
||||||
for _, c := range set {
|
|
||||||
pcore[c] = true
|
|
||||||
}
|
|
||||||
keep := make([]int, 0, len(allowed))
|
|
||||||
for _, cpu := range allowed {
|
|
||||||
if pcore[cpu] {
|
|
||||||
keep = append(keep, cpu)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(keep) == 0 {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
return keep, true
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseCPUList decodes the kernel's cpulist format ("0-7,16-23", "3") into
|
|
||||||
// individual CPU IDs. Empty input yields an empty list.
|
|
||||||
func parseCPUList(s string) ([]int, error) {
|
|
||||||
if s == "" {
|
|
||||||
return nil, nil
|
|
||||||
}
|
|
||||||
var out []int
|
|
||||||
for part := range strings.SplitSeq(s, ",") {
|
|
||||||
part = strings.TrimSpace(part)
|
|
||||||
if part == "" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
lo, hi, isRange := strings.Cut(part, "-")
|
|
||||||
a, err := strconv.Atoi(lo)
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("bad cpulist entry %q: %w", part, err)
|
|
||||||
}
|
|
||||||
if !isRange {
|
|
||||||
out = append(out, a)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
b, err := strconv.Atoi(hi)
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("bad cpulist entry %q: %w", part, err)
|
|
||||||
}
|
|
||||||
if b < a || b-a > 8192 {
|
|
||||||
return nil, fmt.Errorf("bad cpulist range %q", part)
|
|
||||||
}
|
|
||||||
for v := a; v <= b; v++ {
|
|
||||||
out = append(out, v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return out, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func readIntFile(path string) (int, error) {
|
|
||||||
b, err := os.ReadFile(path)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
return strconv.Atoi(strings.TrimSpace(string(b)))
|
|
||||||
}
|
|
||||||
@@ -1,163 +0,0 @@
|
|||||||
//go:build linux
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"slices"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
// fakeSysfs builds a cpuDir tree with the given per-CPU file values.
|
|
||||||
// A nil map for a file means "file absent on every CPU".
|
|
||||||
func fakeSysfs(t *testing.T, capacity, maxFreq map[int]int) string {
|
|
||||||
t.Helper()
|
|
||||||
dir := t.TempDir()
|
|
||||||
write := func(cpu int, rel string, v int) {
|
|
||||||
p := filepath.Join(dir, fmt.Sprintf("cpu%d", cpu), rel)
|
|
||||||
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := os.WriteFile(p, fmt.Appendf(nil, "%d\n", v), 0o644); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for cpu, v := range capacity {
|
|
||||||
write(cpu, "cpu_capacity", v)
|
|
||||||
}
|
|
||||||
for cpu, v := range maxFreq {
|
|
||||||
write(cpu, "cpufreq/cpuinfo_max_freq", v)
|
|
||||||
}
|
|
||||||
return dir
|
|
||||||
}
|
|
||||||
|
|
||||||
func writeCoreMask(t *testing.T, mask string) string {
|
|
||||||
t.Helper()
|
|
||||||
p := filepath.Join(t.TempDir(), "cpus")
|
|
||||||
if err := os.WriteFile(p, []byte(mask+"\n"), 0o644); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsBigLittleCapacity(t *testing.T) {
|
|
||||||
// 4 big (1024) + 4 LITTLE (~290): capacity is authoritative on ARM.
|
|
||||||
dir := fakeSysfs(t, map[int]int{
|
|
||||||
0: 1024, 1: 1024, 2: 1024, 3: 1024,
|
|
||||||
4: 290, 5: 290, 6: 290, 7: 290,
|
|
||||||
}, nil)
|
|
||||||
got, signal := perfCPUsFrom(dir, filepath.Join(dir, "nope"), []int{0, 1, 2, 3, 4, 5, 6, 7})
|
|
||||||
if signal != "cpu_capacity" {
|
|
||||||
t.Fatalf("signal = %q", signal)
|
|
||||||
}
|
|
||||||
if !slices.Equal(got, []int{0, 1, 2, 3}) {
|
|
||||||
t.Errorf("got %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsThreeTierKeepsMid(t *testing.T) {
|
|
||||||
// prime (1024) + mid (~780) + little (~280): 50% keeps prime+mid.
|
|
||||||
dir := fakeSysfs(t, map[int]int{
|
|
||||||
0: 280, 1: 280, 2: 280, 3: 280,
|
|
||||||
4: 780, 5: 780, 6: 780,
|
|
||||||
7: 1024,
|
|
||||||
}, nil)
|
|
||||||
got, _ := perfCPUsFrom(dir, filepath.Join(dir, "nope"), []int{0, 1, 2, 3, 4, 5, 6, 7})
|
|
||||||
if !slices.Equal(got, []int{4, 5, 6, 7}) {
|
|
||||||
t.Errorf("got %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsIntelHybridMask(t *testing.T) {
|
|
||||||
// No cpu_capacity on x86; the P-core PMU mask decides.
|
|
||||||
dir := fakeSysfs(t, nil, nil)
|
|
||||||
mask := writeCoreMask(t, "0-7")
|
|
||||||
got, signal := perfCPUsFrom(dir, mask, []int{0, 1, 2, 3, 8, 9, 10, 11})
|
|
||||||
if signal != "intel_core_pmu" {
|
|
||||||
t.Fatalf("signal = %q", signal)
|
|
||||||
}
|
|
||||||
if !slices.Equal(got, []int{0, 1, 2, 3}) {
|
|
||||||
t.Errorf("got %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsIntelMaskDisjointFallsThrough(t *testing.T) {
|
|
||||||
// Confined to E-cores only: the mask can't help, and equal freqs below
|
|
||||||
// mean nothing else distinguishes them either -> allowed unchanged.
|
|
||||||
dir := fakeSysfs(t, nil, map[int]int{8: 4300000, 9: 4300000})
|
|
||||||
mask := writeCoreMask(t, "0-7")
|
|
||||||
got, signal := perfCPUsFrom(dir, mask, []int{8, 9})
|
|
||||||
if signal != "" || !slices.Equal(got, []int{8, 9}) {
|
|
||||||
t.Errorf("got %v signal %q", got, signal)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsMaxFreqCompactCores(t *testing.T) {
|
|
||||||
// AMD-style compact cores: no capacity, no Intel mask; 3.3 vs 5.7 GHz.
|
|
||||||
dir := fakeSysfs(t, nil, map[int]int{
|
|
||||||
0: 5700000, 1: 5700000, 2: 3300000, 3: 3300000,
|
|
||||||
})
|
|
||||||
got, signal := perfCPUsFrom(dir, filepath.Join(dir, "nope"), []int{0, 1, 2, 3})
|
|
||||||
if signal != "max_freq" {
|
|
||||||
t.Fatalf("signal = %q", signal)
|
|
||||||
}
|
|
||||||
if !slices.Equal(got, []int{0, 1}) {
|
|
||||||
t.Errorf("got %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsFavoredCoreSkewKept(t *testing.T) {
|
|
||||||
// Turbo Boost Max favored cores run a few percent hot; they must not
|
|
||||||
// shrink the candidate set to one or two cores.
|
|
||||||
dir := fakeSysfs(t, nil, map[int]int{
|
|
||||||
0: 5800000, 1: 5700000, 2: 5700000, 3: 5600000,
|
|
||||||
})
|
|
||||||
got, _ := perfCPUsFrom(dir, filepath.Join(dir, "nope"), []int{0, 1, 2, 3})
|
|
||||||
if !slices.Equal(got, []int{0, 1, 2, 3}) {
|
|
||||||
t.Errorf("favored-core skew filtered CPUs: %v", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsHomogeneousInconclusive(t *testing.T) {
|
|
||||||
dir := fakeSysfs(t, nil, map[int]int{0: 3000000, 1: 3000000})
|
|
||||||
got, signal := perfCPUsFrom(dir, filepath.Join(dir, "nope"), []int{0, 1})
|
|
||||||
if signal != "" || !slices.Equal(got, []int{0, 1}) {
|
|
||||||
t.Errorf("got %v signal %q", got, signal)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPerfCPUsNoSysfs(t *testing.T) {
|
|
||||||
dir := t.TempDir()
|
|
||||||
got, signal := perfCPUsFrom(dir, filepath.Join(dir, "nope"), []int{0, 1, 2})
|
|
||||||
if signal != "" || !slices.Equal(got, []int{0, 1, 2}) {
|
|
||||||
t.Errorf("got %v signal %q", got, signal)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseCPUList(t *testing.T) {
|
|
||||||
cases := []struct {
|
|
||||||
in string
|
|
||||||
want []int
|
|
||||||
wantErr bool
|
|
||||||
}{
|
|
||||||
{"0-3", []int{0, 1, 2, 3}, false},
|
|
||||||
{"0-1,16-17", []int{0, 1, 16, 17}, false},
|
|
||||||
{"5", []int{5}, false},
|
|
||||||
{"", nil, false},
|
|
||||||
{"3-1", nil, true},
|
|
||||||
{"a-b", nil, true},
|
|
||||||
{"1,x", nil, true},
|
|
||||||
}
|
|
||||||
for _, c := range cases {
|
|
||||||
got, err := parseCPUList(c.in)
|
|
||||||
if (err != nil) != c.wantErr {
|
|
||||||
t.Errorf("%q: err=%v wantErr=%v", c.in, err, c.wantErr)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if !c.wantErr && !slices.Equal(got, c.want) {
|
|
||||||
t.Errorf("%q: got %v want %v", c.in, got, c.want)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,10 +0,0 @@
|
|||||||
//go:build !linux
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
// perfCPUs is Linux-only sysfs walking; elsewhere report "no distinction".
|
|
||||||
// Default already returns nil off-Linux (util.AllowedCPUs has no answer
|
|
||||||
// there), so this exists to keep the package compiling everywhere.
|
|
||||||
func perfCPUs(allowed []int) ([]int, string) {
|
|
||||||
return allowed, ""
|
|
||||||
}
|
|
||||||
@@ -1,118 +0,0 @@
|
|||||||
//go:build linux
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// readTopology probes the NUMA node and physical-core layout of cpus from
|
|
||||||
// sysfs. Anything sysfs won't say degrades toward flatTopology: an unknown
|
|
||||||
// node becomes node 0, an unknown core becomes a core of its own — either
|
|
||||||
// way the corresponding arrange rule becomes a no-op instead of a wrong
|
|
||||||
// answer.
|
|
||||||
func readTopology(cpus []int) topology {
|
|
||||||
return readTopologyFrom("/sys/devices/system/node", "/sys/devices/system/cpu", cpus)
|
|
||||||
}
|
|
||||||
|
|
||||||
func readTopologyFrom(nodeDir, cpuDir string, cpus []int) topology {
|
|
||||||
coreOf, zeroCore := coreGroups(cpuDir, cpus)
|
|
||||||
return topology{
|
|
||||||
nodeOf: numaNodes(nodeDir, cpus),
|
|
||||||
coreOf: coreOf,
|
|
||||||
zeroCore: zeroCore,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// numaNodes maps each cpu to its NUMA node via
|
|
||||||
// /sys/devices/system/node/nodeN/cpulist. CPUs no node claims (or no node
|
|
||||||
// dirs at all: VMs, non-NUMA kernels) land on node 0.
|
|
||||||
func numaNodes(nodeDir string, cpus []int) map[int]int {
|
|
||||||
out := make(map[int]int, len(cpus))
|
|
||||||
for _, c := range cpus {
|
|
||||||
out[c] = 0
|
|
||||||
}
|
|
||||||
entries, err := os.ReadDir(nodeDir)
|
|
||||||
if err != nil {
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
want := make(map[int]bool, len(cpus))
|
|
||||||
for _, c := range cpus {
|
|
||||||
want[c] = true
|
|
||||||
}
|
|
||||||
for _, e := range entries {
|
|
||||||
id, ok := strings.CutPrefix(e.Name(), "node")
|
|
||||||
if !ok {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
n, err := strconv.Atoi(id)
|
|
||||||
if err != nil {
|
|
||||||
continue // has_cpu, possible, ... share the prefix
|
|
||||||
}
|
|
||||||
b, err := os.ReadFile(filepath.Join(nodeDir, e.Name(), "cpulist"))
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
list, err := parseCPUList(strings.TrimSpace(string(b)))
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for _, c := range list {
|
|
||||||
if want[c] {
|
|
||||||
out[c] = n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
|
|
||||||
// coreGroups maps each cpu to a dense physical-core id derived from its
|
|
||||||
// (physical_package_id, core_id) pair — core_id alone repeats across
|
|
||||||
// sockets. CPUs whose topology files are unreadable get a core of their own.
|
|
||||||
// The second return is the group id of the core CPU 0 lives on, or -1 when
|
|
||||||
// that can't be determined; CPU 0's own files are consulted even when 0 is
|
|
||||||
// not a candidate, so its SMT siblings are recognized under cpusets that
|
|
||||||
// exclude CPU 0 itself.
|
|
||||||
func coreGroups(cpuDir string, cpus []int) (map[int]int, int) {
|
|
||||||
type pkgCore struct{ pkg, core int }
|
|
||||||
pairOf := func(cpu int) (pkgCore, bool) {
|
|
||||||
topoDir := filepath.Join(cpuDir, fmt.Sprintf("cpu%d", cpu), "topology")
|
|
||||||
pkg, err1 := readIntFile(filepath.Join(topoDir, "physical_package_id"))
|
|
||||||
core, err2 := readIntFile(filepath.Join(topoDir, "core_id"))
|
|
||||||
if err1 != nil || err2 != nil {
|
|
||||||
return pkgCore{}, false
|
|
||||||
}
|
|
||||||
return pkgCore{pkg, core}, true
|
|
||||||
}
|
|
||||||
|
|
||||||
ids := map[pkgCore]int{}
|
|
||||||
out := make(map[int]int, len(cpus))
|
|
||||||
next := 0
|
|
||||||
for _, cpu := range cpus {
|
|
||||||
k, ok := pairOf(cpu)
|
|
||||||
if !ok {
|
|
||||||
out[cpu] = next
|
|
||||||
next++
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
id, ok := ids[k]
|
|
||||||
if !ok {
|
|
||||||
id = next
|
|
||||||
next++
|
|
||||||
ids[k] = id
|
|
||||||
}
|
|
||||||
out[cpu] = id
|
|
||||||
}
|
|
||||||
|
|
||||||
zeroCore := -1
|
|
||||||
if k, ok := pairOf(0); ok {
|
|
||||||
if id, ok := ids[k]; ok {
|
|
||||||
zeroCore = id
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return out, zeroCore
|
|
||||||
}
|
|
||||||
@@ -1,111 +0,0 @@
|
|||||||
//go:build linux
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
// fakeTopoSysfs builds nodeDir/cpuDir trees. nodes maps node id -> cpulist
|
|
||||||
// string; cores maps cpu -> (package, core) pair.
|
|
||||||
func fakeTopoSysfs(t *testing.T, nodes map[int]string, cores map[int][2]int) (string, string) {
|
|
||||||
t.Helper()
|
|
||||||
base := t.TempDir()
|
|
||||||
nodeDir := filepath.Join(base, "node")
|
|
||||||
cpuDir := filepath.Join(base, "cpu")
|
|
||||||
for n, list := range nodes {
|
|
||||||
d := filepath.Join(nodeDir, fmt.Sprintf("node%d", n))
|
|
||||||
if err := os.MkdirAll(d, 0o755); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := os.WriteFile(filepath.Join(d, "cpulist"), []byte(list+"\n"), 0o644); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for cpu, pc := range cores {
|
|
||||||
d := filepath.Join(cpuDir, fmt.Sprintf("cpu%d", cpu), "topology")
|
|
||||||
if err := os.MkdirAll(d, 0o755); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := os.WriteFile(filepath.Join(d, "physical_package_id"), fmt.Appendf(nil, "%d\n", pc[0]), 0o644); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
if err := os.WriteFile(filepath.Join(d, "core_id"), fmt.Appendf(nil, "%d\n", pc[1]), 0o644); err != nil {
|
|
||||||
t.Fatal(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nodeDir, cpuDir
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReadTopology(t *testing.T) {
|
|
||||||
// Two nodes; SMT pairs (0,4),(1,5) on node 0 and (2,6),(3,7) on node 1.
|
|
||||||
// core_id repeats across packages on purpose: the pair must disambiguate.
|
|
||||||
nodeDir, cpuDir := fakeTopoSysfs(t,
|
|
||||||
map[int]string{0: "0-1,4-5", 1: "2-3,6-7"},
|
|
||||||
map[int][2]int{
|
|
||||||
0: {0, 0}, 4: {0, 0}, 1: {0, 1}, 5: {0, 1},
|
|
||||||
2: {1, 0}, 6: {1, 0}, 3: {1, 1}, 7: {1, 1},
|
|
||||||
})
|
|
||||||
cpus := []int{0, 1, 2, 3, 4, 5, 6, 7}
|
|
||||||
topo := readTopologyFrom(nodeDir, cpuDir, cpus)
|
|
||||||
|
|
||||||
for _, c := range []int{0, 1, 4, 5} {
|
|
||||||
if topo.nodeOf[c] != 0 {
|
|
||||||
t.Errorf("cpu %d on node %d, want 0", c, topo.nodeOf[c])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
for _, c := range []int{2, 3, 6, 7} {
|
|
||||||
if topo.nodeOf[c] != 1 {
|
|
||||||
t.Errorf("cpu %d on node %d, want 1", c, topo.nodeOf[c])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pairs := [][2]int{{0, 4}, {1, 5}, {2, 6}, {3, 7}}
|
|
||||||
for _, p := range pairs {
|
|
||||||
if topo.coreOf[p[0]] != topo.coreOf[p[1]] {
|
|
||||||
t.Errorf("siblings %v not grouped: %d vs %d", p, topo.coreOf[p[0]], topo.coreOf[p[1]])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if topo.coreOf[0] == topo.coreOf[2] {
|
|
||||||
t.Error("cross-package cores with equal core_id must not merge")
|
|
||||||
}
|
|
||||||
if topo.zeroCore != topo.coreOf[0] {
|
|
||||||
t.Errorf("zeroCore = %d, want %d", topo.zeroCore, topo.coreOf[0])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReadTopologyZeroCoreWithoutZeroCandidate(t *testing.T) {
|
|
||||||
// CPU 0 is not a candidate (cpuset excludes it) but its sibling 4 is:
|
|
||||||
// zeroCore must still identify their shared core.
|
|
||||||
nodeDir, cpuDir := fakeTopoSysfs(t,
|
|
||||||
map[int]string{0: "0-7"},
|
|
||||||
map[int][2]int{0: {0, 0}, 4: {0, 0}, 1: {0, 1}, 5: {0, 1}})
|
|
||||||
topo := readTopologyFrom(nodeDir, cpuDir, []int{1, 4, 5})
|
|
||||||
if topo.zeroCore < 0 || topo.coreOf[4] != topo.zeroCore {
|
|
||||||
t.Errorf("zeroCore = %d, coreOf[4] = %d; sibling of CPU 0 not identified", topo.zeroCore, topo.coreOf[4])
|
|
||||||
}
|
|
||||||
if topo.coreOf[1] == topo.zeroCore {
|
|
||||||
t.Error("cpu 1 wrongly grouped with CPU 0's core")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestReadTopologyMissingSysfs(t *testing.T) {
|
|
||||||
base := t.TempDir()
|
|
||||||
cpus := []int{0, 1, 2}
|
|
||||||
topo := readTopologyFrom(filepath.Join(base, "nope"), filepath.Join(base, "also-nope"), cpus)
|
|
||||||
seen := map[int]bool{}
|
|
||||||
for _, c := range cpus {
|
|
||||||
if topo.nodeOf[c] != 0 {
|
|
||||||
t.Errorf("cpu %d node = %d, want 0", c, topo.nodeOf[c])
|
|
||||||
}
|
|
||||||
if seen[topo.coreOf[c]] {
|
|
||||||
t.Errorf("cpu %d shares a fallback core group", c)
|
|
||||||
}
|
|
||||||
seen[topo.coreOf[c]] = true
|
|
||||||
}
|
|
||||||
if topo.zeroCore != -1 {
|
|
||||||
t.Errorf("zeroCore = %d, want -1 when unknown", topo.zeroCore)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,10 +0,0 @@
|
|||||||
//go:build !linux
|
|
||||||
|
|
||||||
package cpupick
|
|
||||||
|
|
||||||
// readTopology has no sysfs to consult off Linux; the flat stand-in makes
|
|
||||||
// arrange's NUMA and SMT rules no-ops. Default is already nil off Linux
|
|
||||||
// (util.AllowedCPUs has no answer there) — this keeps the package compiling.
|
|
||||||
func readTopology(cpus []int) topology {
|
|
||||||
return flatTopology(cpus)
|
|
||||||
}
|
|
||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
+5
-2
@@ -1,15 +1,18 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"log/slog"
|
"io"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"os"
|
"os"
|
||||||
"strings"
|
"strings"
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
|
"log/slog"
|
||||||
|
|
||||||
"dario.cat/mergo"
|
"dario.cat/mergo"
|
||||||
"github.com/google/gopacket"
|
"github.com/google/gopacket"
|
||||||
"github.com/google/gopacket/layers"
|
"github.com/google/gopacket/layers"
|
||||||
@@ -379,7 +382,7 @@ func getAddrs(ns []netip.Prefix) []netip.Addr {
|
|||||||
func NewTestLogger() *slog.Logger {
|
func NewTestLogger() *slog.Logger {
|
||||||
v := os.Getenv("TEST_LOGS")
|
v := os.Getenv("TEST_LOGS")
|
||||||
if v == "" {
|
if v == "" {
|
||||||
return slog.New(slog.DiscardHandler)
|
return slog.New(slog.NewTextHandler(io.Discard, nil))
|
||||||
}
|
}
|
||||||
|
|
||||||
level := slog.LevelInfo
|
level := slog.LevelInfo
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
+1
-57
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
@@ -222,60 +223,3 @@ func TestRebindAdvertisesNewAddressAfterMove(t *testing.T) {
|
|||||||
lhControl.Stop()
|
lhControl.Stop()
|
||||||
myControl.Stop()
|
myControl.Stop()
|
||||||
}
|
}
|
||||||
|
|
||||||
// A relayed send records traffic but must not consume the rebind epoch. If it does, the next direct send to the
|
|
||||||
// relay host sees the epoch already current and never requeries, so the far side is never told to punch at our
|
|
||||||
// new address. This pins the SendVia call site, which the unit tests cannot reach.
|
|
||||||
func TestRebindRequeriesAfterRelayedSend(t *testing.T) {
|
|
||||||
t.Parallel()
|
|
||||||
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, time.Now(), time.Now().Add(10*time.Minute), nil, nil, []string{})
|
|
||||||
|
|
||||||
// No lighthouse on purpose: it would hand out a direct address for them and nothing would relay.
|
|
||||||
// Long connection manager timers so it never fires a direct test packet at the relay tunnel and bumps its
|
|
||||||
// epoch mid-test, which is the only other thing that touches that tunnel and would flake the assertion below.
|
|
||||||
myControl, myVpnIpNet, _, _ := newSimpleServer(cert.Version2, ca, caKey, "me", "10.128.0.1/24",
|
|
||||||
m{"relay": m{"use_relays": true}, "timers": m{"connection_alive_interval": 3600, "pending_deletion_interval": 3600}})
|
|
||||||
relayControl, relayVpnIpNet, relayUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "relay", "10.128.0.128/24", m{"relay": m{"am_relay": true}})
|
|
||||||
theirControl, theirVpnIpNet, theirUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "them", "10.128.0.2/24", m{"relay": m{"use_relays": true}})
|
|
||||||
|
|
||||||
myControl.InjectLightHouseAddr(relayVpnIpNet[0].Addr(), relayUdpAddr)
|
|
||||||
myControl.InjectRelays(theirVpnIpNet[0].Addr(), []netip.Addr{relayVpnIpNet[0].Addr()})
|
|
||||||
relayControl.InjectLightHouseAddr(theirVpnIpNet[0].Addr(), theirUdpAddr)
|
|
||||||
|
|
||||||
r := router.NewR(t, myControl, relayControl, theirControl)
|
|
||||||
defer r.RenderFlow()
|
|
||||||
|
|
||||||
myControl.Start()
|
|
||||||
relayControl.Start()
|
|
||||||
theirControl.Start()
|
|
||||||
|
|
||||||
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpnIpNet[0].Addr(), 80, myVpnIpNet[0].Addr(), 80, []byte("establish")))
|
|
||||||
r.RouteForAllUntilTxTun(theirControl)
|
|
||||||
r.RouteFor(time.Millisecond * 500)
|
|
||||||
|
|
||||||
hi := myControl.GetHostInfoByVpnAddr(theirVpnIpNet[0].Addr(), false)
|
|
||||||
require.NotNil(t, hi, "expected a tunnel to them")
|
|
||||||
require.NotEmpty(t, hi.CurrentRelaysToMe, "them must be reachable only via the relay for this test to mean anything")
|
|
||||||
// sendNoMetrics only reaches SendVia when there is no direct remote, so pin that too. Without this the test
|
|
||||||
// keeps passing while quietly sending direct and never exercising the relay path.
|
|
||||||
require.False(t, hi.CurrentRemote.IsValid(), "them must have no direct remote, otherwise SendVia is never called")
|
|
||||||
|
|
||||||
before, ok := myControl.GetRebindEpochFor(relayVpnIpNet[0].Addr())
|
|
||||||
require.True(t, ok, "expected a tunnel to the relay")
|
|
||||||
|
|
||||||
myControl.RebindUDPServer()
|
|
||||||
|
|
||||||
// Traffic to them goes through SendVia on the relay tunnel. That must record traffic without consuming the
|
|
||||||
// relay tunnel's own epoch edge, which belongs to the direct path.
|
|
||||||
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpnIpNet[0].Addr(), 80, myVpnIpNet[0].Addr(), 80, []byte("relayed")))
|
|
||||||
r.RouteForAllUntilTxTun(theirControl)
|
|
||||||
|
|
||||||
after, ok := myControl.GetRebindEpochFor(relayVpnIpNet[0].Addr())
|
|
||||||
require.True(t, ok)
|
|
||||||
assert.Equal(t, before, after,
|
|
||||||
"a relayed send consumed the relay tunnel's rebind epoch, so the next direct send will not requery")
|
|
||||||
|
|
||||||
myControl.Stop()
|
|
||||||
relayControl.Stop()
|
|
||||||
theirControl.Stop()
|
|
||||||
}
|
|
||||||
@@ -1,135 +0,0 @@
|
|||||||
//go:build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
|
||||||
|
|
||||||
import (
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula"
|
|
||||||
"github.com/slackhq/nebula/cert"
|
|
||||||
"github.com/slackhq/nebula/cert_test"
|
|
||||||
"github.com/slackhq/nebula/e2e/router"
|
|
||||||
"github.com/slackhq/nebula/udp"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TestRecoveryTiming measures how long a tunnel takes to come back after the peer stops accepting our traffic,
|
|
||||||
// which is what a laptop waking on a new network looks like from the peer's side: its NAT has no state for where
|
|
||||||
// we are now, so everything we send disappears.
|
|
||||||
//
|
|
||||||
// It is a measurement, not a pass/fail assertion. Recovery is timed to the moment the peer punches back at us,
|
|
||||||
// since that is when its NAT opens and the tunnel is usable again.
|
|
||||||
//
|
|
||||||
// go test -tags e2e_testing -v -run TestRecoveryTiming ./e2e/
|
|
||||||
func TestRecoveryTiming(t *testing.T) {
|
|
||||||
for _, tc := range []struct {
|
|
||||||
name string
|
|
||||||
rebind bool
|
|
||||||
}{
|
|
||||||
{"no trigger", false},
|
|
||||||
{"rebind counter", true},
|
|
||||||
} {
|
|
||||||
t.Run(tc.name, func(t *testing.T) {
|
|
||||||
d, lost := measureRecovery(t, tc.rebind)
|
|
||||||
t.Logf("RESULT %-16s recovered in %-9v (%d packets lost)", tc.name, d.Round(time.Millisecond), lost)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// measureRecovery returns how long until the peer punched back, and how many of our packets died meanwhile. When
|
|
||||||
// rebind is true we call RebindUDPServer once the tunnel goes dark, which is what the darwin network change
|
|
||||||
// monitor does and what iOS has always done. When false, nothing tells nebula anything is wrong.
|
|
||||||
func measureRecovery(t *testing.T, rebind bool) (time.Duration, int) {
|
|
||||||
t.Helper()
|
|
||||||
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, time.Now(), time.Now().Add(10*time.Minute), nil, nil, []string{})
|
|
||||||
|
|
||||||
lhControl, lhVpnIpNet, lhUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "lh", "10.128.0.1/24", m{
|
|
||||||
"lighthouse": m{"am_lighthouse": true},
|
|
||||||
})
|
|
||||||
|
|
||||||
peerCfg := m{
|
|
||||||
"lighthouse": m{
|
|
||||||
"hosts": []any{lhVpnIpNet[0].Addr().String()},
|
|
||||||
"interval": 600,
|
|
||||||
"local_allow_list": m{
|
|
||||||
"10.0.0.0/24": true,
|
|
||||||
"::/0": false,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
"static_host_map": m{
|
|
||||||
lhVpnIpNet[0].Addr().String(): []any{lhUdpAddr.String()},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
myControl, myVpnIpNet, myUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "me", "10.128.0.2/24", peerCfg)
|
|
||||||
theirControl, theirVpnIpNet, theirUdpAddr, _ := newSimpleServer(cert.Version2, ca, caKey, "them", "10.128.0.3/24", peerCfg)
|
|
||||||
|
|
||||||
r := router.NewR(t, lhControl, myControl, theirControl)
|
|
||||||
defer r.RenderFlow()
|
|
||||||
defer func() {
|
|
||||||
lhControl.Stop()
|
|
||||||
myControl.Stop()
|
|
||||||
theirControl.Stop()
|
|
||||||
}()
|
|
||||||
|
|
||||||
lhControl.Start()
|
|
||||||
myControl.Start()
|
|
||||||
theirControl.Start()
|
|
||||||
r.RouteFor(time.Millisecond * 500)
|
|
||||||
|
|
||||||
myControl.InjectLightHouseAddr(theirVpnIpNet[0].Addr(), theirUdpAddr)
|
|
||||||
theirControl.InjectLightHouseAddr(myVpnIpNet[0].Addr(), myUdpAddr)
|
|
||||||
|
|
||||||
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpnIpNet[0].Addr(), 80, myVpnIpNet[0].Addr(), 80, []byte("establish")))
|
|
||||||
r.RouteFor(time.Second)
|
|
||||||
if myControl.GetHostInfoByVpnAddr(theirVpnIpNet[0].Addr(), false) == nil {
|
|
||||||
t.Fatal("failed to establish the tunnel we are measuring")
|
|
||||||
}
|
|
||||||
r.RouteFor(time.Millisecond * 500)
|
|
||||||
|
|
||||||
// From here the peer's NAT has no state for us, everything we send it disappears
|
|
||||||
start := time.Now()
|
|
||||||
blackholed := 0
|
|
||||||
var recovered time.Duration
|
|
||||||
|
|
||||||
if rebind {
|
|
||||||
myControl.RebindUDPServer()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Keep the tun busy the way someone retrying a stalled connection would
|
|
||||||
stop := make(chan struct{})
|
|
||||||
defer close(stop)
|
|
||||||
go func() {
|
|
||||||
tick := time.NewTicker(time.Millisecond * 200)
|
|
||||||
defer tick.Stop()
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case <-stop:
|
|
||||||
return
|
|
||||||
case <-tick.C:
|
|
||||||
myControl.InjectTunPacket(BuildTunUDPPacket(
|
|
||||||
theirVpnIpNet[0].Addr(), 80, myVpnIpNet[0].Addr(), 80, []byte("retry")))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
r.RouteForAllExitFuncOrTimeout(time.Second*30, func(p *udp.Packet, c *nebula.Control) router.ExitType {
|
|
||||||
if c == theirControl && p.From == myControl.GetUDPAddr() {
|
|
||||||
blackholed++
|
|
||||||
return router.Drop
|
|
||||||
}
|
|
||||||
|
|
||||||
// The peer reaching us directly is the moment its NAT opened, whether that is a punch or a handshake
|
|
||||||
if c == myControl && p.From == theirUdpAddr {
|
|
||||||
recovered = time.Since(start)
|
|
||||||
return router.RouteAndExit
|
|
||||||
}
|
|
||||||
|
|
||||||
return router.KeepRouting
|
|
||||||
})
|
|
||||||
|
|
||||||
if recovered == 0 {
|
|
||||||
t.Fatalf("no recovery within 30s (%d packets blackholed)", blackholed)
|
|
||||||
}
|
|
||||||
return recovered, blackholed
|
|
||||||
}
|
|
||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package router
|
package router
|
||||||
|
|
||||||
|
|||||||
+5
-22
@@ -1,17 +1,16 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package router
|
package router
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"context"
|
"context"
|
||||||
"fmt"
|
"fmt"
|
||||||
"maps"
|
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"os"
|
"os"
|
||||||
"path/filepath"
|
"path/filepath"
|
||||||
"reflect"
|
"reflect"
|
||||||
"regexp"
|
"regexp"
|
||||||
"slices"
|
|
||||||
"sort"
|
"sort"
|
||||||
"sync"
|
"sync"
|
||||||
"sync/atomic"
|
"sync/atomic"
|
||||||
@@ -23,6 +22,7 @@ import (
|
|||||||
"github.com/slackhq/nebula"
|
"github.com/slackhq/nebula"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
|
"golang.org/x/exp/maps"
|
||||||
)
|
)
|
||||||
|
|
||||||
// outNatKey is the (from, to) pair used by outNat. Comparable struct, so it works as a map key without the
|
// outNatKey is the (from, to) pair used by outNat. Comparable struct, so it works as a map key without the
|
||||||
@@ -153,9 +153,6 @@ const (
|
|||||||
ExitNow ExitType = 1
|
ExitNow ExitType = 1
|
||||||
// RouteAndExit routes this packet and exits immediately afterwards
|
// RouteAndExit routes this packet and exits immediately afterwards
|
||||||
RouteAndExit ExitType = 2
|
RouteAndExit ExitType = 2
|
||||||
// Drop discards this packet without delivering it and keeps routing. Use it to simulate a blackhole, such as
|
|
||||||
// a restrictive NAT refusing traffic from an address it has not seen.
|
|
||||||
Drop ExitType = 3
|
|
||||||
)
|
)
|
||||||
|
|
||||||
type ExitFunc func(packet *udp.Packet, receiver *nebula.Control) ExitType
|
type ExitFunc func(packet *udp.Packet, receiver *nebula.Control) ExitType
|
||||||
@@ -166,9 +163,7 @@ type ExitFunc func(packet *udp.Packet, receiver *nebula.Control) ExitType
|
|||||||
func NewR(t testing.TB, controls ...*nebula.Control) *R {
|
func NewR(t testing.TB, controls ...*nebula.Control) *R {
|
||||||
ctx, cancel := context.WithCancel(context.Background())
|
ctx, cancel := context.WithCancel(context.Background())
|
||||||
|
|
||||||
// t.Name() contains a slash for subtests, so the flow log can land in a nested directory
|
if err := os.MkdirAll("mermaid", 0755); err != nil {
|
||||||
fn := filepath.Join("mermaid", fmt.Sprintf("%s.md", t.Name()))
|
|
||||||
if err := os.MkdirAll(filepath.Dir(fn), 0755); err != nil {
|
|
||||||
panic(err)
|
panic(err)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -179,7 +174,7 @@ func NewR(t testing.TB, controls ...*nebula.Control) *R {
|
|||||||
outNat: make(map[outNatKey]netip.AddrPort),
|
outNat: make(map[outNatKey]netip.AddrPort),
|
||||||
flow: []flowEntry{},
|
flow: []flowEntry{},
|
||||||
ignoreFlows: []ignoreFlow{},
|
ignoreFlows: []ignoreFlow{},
|
||||||
fn: fn,
|
fn: filepath.Join("mermaid", fmt.Sprintf("%s.md", t.Name())),
|
||||||
t: t,
|
t: t,
|
||||||
cancelRender: cancel,
|
cancelRender: cancel,
|
||||||
}
|
}
|
||||||
@@ -374,7 +369,7 @@ func (r *R) RenderHostmaps(title string, controls ...*nebula.Control) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (r *R) renderHostmaps(title string) {
|
func (r *R) renderHostmaps(title string) {
|
||||||
c := slices.AppendSeq(make([]*nebula.Control, 0, len(r.controls)), maps.Values(r.controls))
|
c := maps.Values(r.controls)
|
||||||
sort.SliceStable(c, func(i, j int) bool {
|
sort.SliceStable(c, func(i, j int) bool {
|
||||||
return c[i].GetVpnAddrs()[0].Compare(c[j].GetVpnAddrs()[0]) > 0
|
return c[i].GetVpnAddrs()[0].Compare(c[j].GetVpnAddrs()[0]) > 0
|
||||||
})
|
})
|
||||||
@@ -692,10 +687,6 @@ func (r *R) RouteExitFunc(sender *nebula.Control, whatDo ExitFunc) {
|
|||||||
p.Release()
|
p.Release()
|
||||||
return
|
return
|
||||||
|
|
||||||
case Drop:
|
|
||||||
// Record it so the flow log shows the attempt, but never hand it to the receiver
|
|
||||||
r.unlockedInjectFlow(sender, receiver, p, false)
|
|
||||||
|
|
||||||
case KeepRouting:
|
case KeepRouting:
|
||||||
fp := r.unlockedInjectFlow(sender, receiver, p, false)
|
fp := r.unlockedInjectFlow(sender, receiver, p, false)
|
||||||
receiver.InjectUDPPacket(p)
|
receiver.InjectUDPPacket(p)
|
||||||
@@ -788,10 +779,6 @@ func (r *R) RouteForAllExitFuncOrTimeout(timeout time.Duration, whatDo ExitFunc)
|
|||||||
p.Release()
|
p.Release()
|
||||||
return true
|
return true
|
||||||
|
|
||||||
case Drop:
|
|
||||||
// Record it so the flow log shows the attempt, but never hand it to the receiver
|
|
||||||
r.unlockedInjectFlow(cm[x], receiver, p, false)
|
|
||||||
|
|
||||||
case KeepRouting:
|
case KeepRouting:
|
||||||
fp := r.unlockedInjectFlow(cm[x], receiver, p, false)
|
fp := r.unlockedInjectFlow(cm[x], receiver, p, false)
|
||||||
receiver.InjectUDPPacket(p)
|
receiver.InjectUDPPacket(p)
|
||||||
@@ -897,10 +884,6 @@ func (r *R) RouteForAllExitFunc(whatDo ExitFunc) {
|
|||||||
p.Release()
|
p.Release()
|
||||||
return
|
return
|
||||||
|
|
||||||
case Drop:
|
|
||||||
// Record it so the flow log shows the attempt, but never hand it to the receiver
|
|
||||||
r.unlockedInjectFlow(cm[x], receiver, p, false)
|
|
||||||
|
|
||||||
case KeepRouting:
|
case KeepRouting:
|
||||||
fp := r.unlockedInjectFlow(cm[x], receiver, p, false)
|
fp := r.unlockedInjectFlow(cm[x], receiver, p, false)
|
||||||
receiver.InjectUDPPacket(p)
|
receiver.InjectUDPPacket(p)
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
|
// +build e2e_testing
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
+7
-49
@@ -131,16 +131,13 @@ listen:
|
|||||||
port: 4242
|
port: 4242
|
||||||
# Sets the max number of packets to pull from the kernel for each syscall (under systems that support recvmmsg)
|
# Sets the max number of packets to pull from the kernel for each syscall (under systems that support recvmmsg)
|
||||||
# default is 64, does not support reload
|
# default is 64, does not support reload
|
||||||
# Note: on Linux with UDP GRO (kernel 5.10+), each receive slot is sized for a full 64KiB coalesced
|
|
||||||
# superpacket, so the receive scratch is batch * 64KiB per listening socket (~4MiB per routine at the
|
|
||||||
# default of 64). Lower this to trade peak per-syscall throughput for memory on constrained hosts.
|
|
||||||
#batch: 64
|
#batch: 64
|
||||||
# Linux only. Configure socket buffers for the udp side (outside), leave unset to use the system defaults. Values will be doubled by the kernel
|
# Configure socket buffers for the udp side (outside), leave unset to use the system defaults. Values will be doubled by the kernel
|
||||||
# Default is net.core.rmem_default and net.core.wmem_default (/proc/sys/net/core/rmem_default and /proc/sys/net/core/rmem_default)
|
# Default is net.core.rmem_default and net.core.wmem_default (/proc/sys/net/core/rmem_default and /proc/sys/net/core/rmem_default)
|
||||||
# Maximum is limited by memory in the system, SO_RCVBUFFORCE and SO_SNDBUFFORCE is used to avoid having to raise the system wide
|
# Maximum is limited by memory in the system, SO_RCVBUFFORCE and SO_SNDBUFFORCE is used to avoid having to raise the system wide
|
||||||
# max, net.core.rmem_max and net.core.wmem_max
|
# max, net.core.rmem_max and net.core.wmem_max
|
||||||
read_buffer: 3412512
|
#read_buffer: 10485760
|
||||||
write_buffer: 3412512
|
#write_buffer: 10485760
|
||||||
|
|
||||||
# On Windows only
|
# On Windows only
|
||||||
# When true, Nebula installs a WFP (Windows Filtering Platform) PERMIT filter scoped to UDP at the listener port.
|
# When true, Nebula installs a WFP (Windows Filtering Platform) PERMIT filter scoped to UDP at the listener port.
|
||||||
@@ -172,8 +169,6 @@ listen:
|
|||||||
# allowing for more precise routing decisions based on the packet tags. Default is 0 meaning no mark is set.
|
# allowing for more precise routing decisions based on the packet tags. Default is 0 meaning no mark is set.
|
||||||
# This setting is reloadable.
|
# This setting is reloadable.
|
||||||
#so_mark: 0
|
#so_mark: 0
|
||||||
# the udp_offloads setting controls if Nebula will attempt to enable GSO and GRO for its UDP socket(s). Linux only, not reloadable.
|
|
||||||
# udp_offloads: false
|
|
||||||
|
|
||||||
# Routines is the number of thread pairs to run that consume from the tun and UDP queues.
|
# Routines is the number of thread pairs to run that consume from the tun and UDP queues.
|
||||||
# Currently, this defaults to 1 which means we have 1 tun queue reader and 1
|
# Currently, this defaults to 1 which means we have 1 tun queue reader and 1
|
||||||
@@ -262,48 +257,11 @@ tun:
|
|||||||
drop_local_broadcast: false
|
drop_local_broadcast: false
|
||||||
# Toggles forwarding of multicast packets
|
# Toggles forwarding of multicast packets
|
||||||
drop_multicast: false
|
drop_multicast: false
|
||||||
# Sets the transmit queue length, if you notice lots of transmit drops on the tun it may help to raise this number. Default is 5000
|
# Sets the transmit queue length, if you notice lots of transmit drops on the tun it may help to raise this number. Default is 500
|
||||||
tx_queue: 5000
|
tx_queue: 500
|
||||||
# Default MTU for every packet, safe setting is (and the default) 1300 for internet based traffic
|
# Default MTU for every packet, safe setting is (and the default) 1300 for internet based traffic
|
||||||
# Anything above 8937, here or on a route below, is capped to 8937 with a warning
|
|
||||||
mtu: 1300
|
mtu: 1300
|
||||||
|
|
||||||
# the use_offloads setting controls if Nebula will attempt to enable GSO and GRO for the tun device. Linux only, not reloadable.
|
|
||||||
#use_offloads: false
|
|
||||||
|
|
||||||
# Linux only. pin_threads pins each tun reader/encrypt OS thread to a single CPU. This keeps every goroutine's
|
|
||||||
# batched sends flowing through one XPS-selected NIC TX ring, so packets within a flow stay ordered on the wire
|
|
||||||
# instead of being sprayed across multiple TX rings and reordered. Not reloadable. Coerced to false if routines <= 1.
|
|
||||||
#pin_threads: true
|
|
||||||
|
|
||||||
# pin_threads_key helps the CPU-auto-selector shuffle which CPUs are chosen for pinning.
|
|
||||||
# Valid options are "pid" or "port". Use "port" if you want Nebula to choose the same cores every time, which is nice for benchmarking.
|
|
||||||
# Linux only, not reloadable.
|
|
||||||
#pin_threads_key: "pid"
|
|
||||||
|
|
||||||
# Linux only. cpu_affinity overrides which CPUs the tun reader threads pin to: a list of CPU IDs, one per routine
|
|
||||||
# (see the top-level `routines` setting). Lists shorter than `routines` are modulo-cycled across the queues; extra
|
|
||||||
# entries are ignored. IDs must be within the process's allowed CPU set, so this respects taskset / cgroup cpusets;
|
|
||||||
# a non-integer or not-allowed entry disables the override, leaving the default pin selection described below.
|
|
||||||
# Only meaningful while pin_threads is true. Not reloadable.
|
|
||||||
# When unset (or rejected), the default spread prefers performance cores on heterogeneous CPUs (ARM big.LITTLE,
|
|
||||||
# Intel P/E hybrids, AMD compact cores), keeps all readers on one NUMA node and on distinct physical cores when the
|
|
||||||
# topology allows (SMT siblings last), leaves CPU 0's physical core as a last resort, and rotates its starting
|
|
||||||
# point per instance (keyed by the bound UDP port) so co-located nebulas don't stack their readers onto the
|
|
||||||
# same cores.
|
|
||||||
#cpu_affinity:
|
|
||||||
# - 2
|
|
||||||
# - 4
|
|
||||||
|
|
||||||
# Linux only. avoid_cpus lists CPU IDs the tun readers are never pinned to, exactly as listed (SMT siblings are not
|
|
||||||
# added for you). The default pin selection skips them, and a cpu_affinity entry naming one is rejected like any
|
|
||||||
# other invalid entry. Other threads are not restricted, and the setting does nothing with pin_threads: false. An
|
|
||||||
# invalid list, or one covering every allowed CPU, is ignored with a warning. Not reloadable. To keep Nebula off the
|
|
||||||
# underlay NIC's receive IRQ CPUs, find them in /proc/interrupts and /proc/irq/<IRQ>/effective_affinity_list, add
|
|
||||||
# their SMT siblings from /sys/devices/system/cpu/cpu<N>/topology/thread_siblings_list if you want those kept clear
|
|
||||||
# too, and revisit the list when IRQ placement changes.
|
|
||||||
#avoid_cpus: []
|
|
||||||
|
|
||||||
# Route based MTU overrides, you have known vpn ip paths that can support larger MTUs you can increase/decrease them here
|
# Route based MTU overrides, you have known vpn ip paths that can support larger MTUs you can increase/decrease them here
|
||||||
routes:
|
routes:
|
||||||
#- mtu: 8800
|
#- mtu: 8800
|
||||||
@@ -420,8 +378,8 @@ logging:
|
|||||||
#try_interval: 100ms
|
#try_interval: 100ms
|
||||||
#retries: 20
|
#retries: 20
|
||||||
|
|
||||||
# query_buffer is the size of the buffer channel for querying lighthouses, drops are recorded in the lighthouse.query.dropped metric.
|
# query_buffer is the size of the buffer channel for querying lighthouses
|
||||||
#query_buffer: 1024
|
#query_buffer: 64
|
||||||
|
|
||||||
# trigger_buffer is the size of the buffer channel for quickly sending handshakes
|
# trigger_buffer is the size of the buffer channel for quickly sending handshakes
|
||||||
# after receiving the response for lighthouse queries
|
# after receiving the response for lighthouse queries
|
||||||
|
|||||||
+14
-15
@@ -21,7 +21,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/firewall"
|
"github.com/slackhq/nebula/firewall"
|
||||||
"github.com/slackhq/nebula/iputil"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
type FirewallInterface interface {
|
type FirewallInterface interface {
|
||||||
@@ -263,11 +262,11 @@ func (f *Firewall) AddRule(incoming bool, proto uint8, startPort int32, endPort
|
|||||||
}
|
}
|
||||||
|
|
||||||
switch proto {
|
switch proto {
|
||||||
case iputil.IPProtocolTCP:
|
case firewall.ProtoTCP:
|
||||||
fp = ft.TCP
|
fp = ft.TCP
|
||||||
case iputil.IPProtocolUDP:
|
case firewall.ProtoUDP:
|
||||||
fp = ft.UDP
|
fp = ft.UDP
|
||||||
case iputil.IPProtocolICMP, iputil.IPProtocolICMPv6:
|
case firewall.ProtoICMP, firewall.ProtoICMPv6:
|
||||||
//ICMP traffic doesn't have ports, so we always coerce to "any", even if a value is provided
|
//ICMP traffic doesn't have ports, so we always coerce to "any", even if a value is provided
|
||||||
if startPort != firewall.PortAny {
|
if startPort != firewall.PortAny {
|
||||||
f.l.Warn("ignoring port specification for ICMP firewall rule", "startPort", startPort)
|
f.l.Warn("ignoring port specification for ICMP firewall rule", "startPort", startPort)
|
||||||
@@ -365,13 +364,13 @@ func AddFirewallRulesFromConfig(l *slog.Logger, inbound bool, c *config.C, fw Fi
|
|||||||
proto = firewall.ProtoAny
|
proto = firewall.ProtoAny
|
||||||
startPort, endPort, err = parsePort(sPort)
|
startPort, endPort, err = parsePort(sPort)
|
||||||
case "tcp":
|
case "tcp":
|
||||||
proto = iputil.IPProtocolTCP
|
proto = firewall.ProtoTCP
|
||||||
startPort, endPort, err = parsePort(sPort)
|
startPort, endPort, err = parsePort(sPort)
|
||||||
case "udp":
|
case "udp":
|
||||||
proto = iputil.IPProtocolUDP
|
proto = firewall.ProtoUDP
|
||||||
startPort, endPort, err = parsePort(sPort)
|
startPort, endPort, err = parsePort(sPort)
|
||||||
case "icmp":
|
case "icmp":
|
||||||
proto = iputil.IPProtocolICMP
|
proto = firewall.ProtoICMP
|
||||||
startPort = firewall.PortAny
|
startPort = firewall.PortAny
|
||||||
endPort = firewall.PortAny
|
endPort = firewall.PortAny
|
||||||
if sPort != "" {
|
if sPort != "" {
|
||||||
@@ -561,9 +560,9 @@ func (f *Firewall) inConns(fp firewall.Packet, h *HostInfo, caPool *cert.CAPool,
|
|||||||
}
|
}
|
||||||
|
|
||||||
switch fp.Protocol {
|
switch fp.Protocol {
|
||||||
case iputil.IPProtocolTCP:
|
case firewall.ProtoTCP:
|
||||||
c.Expires = time.Now().Add(f.TCPTimeout)
|
c.Expires = time.Now().Add(f.TCPTimeout)
|
||||||
case iputil.IPProtocolUDP:
|
case firewall.ProtoUDP:
|
||||||
c.Expires = time.Now().Add(f.UDPTimeout)
|
c.Expires = time.Now().Add(f.UDPTimeout)
|
||||||
default:
|
default:
|
||||||
c.Expires = time.Now().Add(f.DefaultTimeout)
|
c.Expires = time.Now().Add(f.DefaultTimeout)
|
||||||
@@ -583,9 +582,9 @@ func (f *Firewall) addConn(fp firewall.Packet, incoming bool) {
|
|||||||
c := &conn{}
|
c := &conn{}
|
||||||
|
|
||||||
switch fp.Protocol {
|
switch fp.Protocol {
|
||||||
case iputil.IPProtocolTCP:
|
case firewall.ProtoTCP:
|
||||||
timeout = f.TCPTimeout
|
timeout = f.TCPTimeout
|
||||||
case iputil.IPProtocolUDP:
|
case firewall.ProtoUDP:
|
||||||
timeout = f.UDPTimeout
|
timeout = f.UDPTimeout
|
||||||
default:
|
default:
|
||||||
timeout = f.DefaultTimeout
|
timeout = f.DefaultTimeout
|
||||||
@@ -636,15 +635,15 @@ func (ft *FirewallTable) match(p firewall.Packet, incoming bool, c *cert.CachedC
|
|||||||
}
|
}
|
||||||
|
|
||||||
switch p.Protocol {
|
switch p.Protocol {
|
||||||
case iputil.IPProtocolTCP:
|
case firewall.ProtoTCP:
|
||||||
if ft.TCP.match(p, incoming, c, caPool) {
|
if ft.TCP.match(p, incoming, c, caPool) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case iputil.IPProtocolUDP:
|
case firewall.ProtoUDP:
|
||||||
if ft.UDP.match(p, incoming, c, caPool) {
|
if ft.UDP.match(p, incoming, c, caPool) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case iputil.IPProtocolICMP, iputil.IPProtocolICMPv6:
|
case firewall.ProtoICMP, firewall.ProtoICMPv6:
|
||||||
if ft.ICMP.match(p, incoming, c, caPool) {
|
if ft.ICMP.match(p, incoming, c, caPool) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
@@ -681,7 +680,7 @@ func (fp firewallPort) match(p firewall.Packet, incoming bool, c *cert.CachedCer
|
|||||||
}
|
}
|
||||||
|
|
||||||
// this branch is here to catch traffic from FirewallTable.Any.match and FirewallTable.ICMP.match
|
// this branch is here to catch traffic from FirewallTable.Any.match and FirewallTable.ICMP.match
|
||||||
if p.Protocol == iputil.IPProtocolICMP || p.Protocol == iputil.IPProtocolICMPv6 {
|
if p.Protocol == firewall.ProtoICMP || p.Protocol == firewall.ProtoICMPv6 {
|
||||||
// port numbers are re-used for connection tracking of ICMP,
|
// port numbers are re-used for connection tracking of ICMP,
|
||||||
// but we don't want to actually filter on them.
|
// but we don't want to actually filter on them.
|
||||||
return fp[firewall.PortAny].match(p, c, caPool)
|
return fp[firewall.PortAny].match(p, c, caPool)
|
||||||
|
|||||||
+2
-4
@@ -5,8 +5,6 @@ import (
|
|||||||
"log/slog"
|
"log/slog"
|
||||||
"sync/atomic"
|
"sync/atomic"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/logging"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
// ConntrackCache is used as a local routine cache to know if a given flow
|
// ConntrackCache is used as a local routine cache to know if a given flow
|
||||||
@@ -58,8 +56,8 @@ func (c *ConntrackCacheTicker) Get() ConntrackCache {
|
|||||||
if tick := c.cacheTick.Load(); tick != c.cacheV {
|
if tick := c.cacheTick.Load(); tick != c.cacheV {
|
||||||
c.cacheV = tick
|
c.cacheV = tick
|
||||||
if ll := len(c.cache); ll > 0 {
|
if ll := len(c.cache); ll > 0 {
|
||||||
if c.l.Enabled(context.Background(), logging.LevelTrace) {
|
if c.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
c.l.Log(context.Background(), logging.LevelTrace, "resetting conntrack cache", "len", ll)
|
c.l.Debug("resetting conntrack cache", "len", ll)
|
||||||
}
|
}
|
||||||
c.cache = make(ConntrackCache, ll)
|
c.cache = make(ConntrackCache, ll)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -6,7 +6,6 @@ import (
|
|||||||
"strings"
|
"strings"
|
||||||
"testing"
|
"testing"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/logging"
|
|
||||||
"github.com/slackhq/nebula/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
)
|
)
|
||||||
@@ -22,7 +21,7 @@ func newFixedTicker(t *testing.T, l *slog.Logger, cacheLen int) *ConntrackCacheT
|
|||||||
l: l,
|
l: l,
|
||||||
cache: make(ConntrackCache, cacheLen),
|
cache: make(ConntrackCache, cacheLen),
|
||||||
}
|
}
|
||||||
for i := range cacheLen {
|
for i := 0; i < cacheLen; i++ {
|
||||||
c.cache[Packet{LocalPort: uint16(i) + 1}] = struct{}{}
|
c.cache[Packet{LocalPort: uint16(i) + 1}] = struct{}{}
|
||||||
}
|
}
|
||||||
c.cacheTick.Store(1) // cacheV starts at 0, so Get() takes the reset path
|
c.cacheTick.Store(1) // cacheV starts at 0, so Get() takes the reset path
|
||||||
@@ -31,27 +30,27 @@ func newFixedTicker(t *testing.T, l *slog.Logger, cacheLen int) *ConntrackCacheT
|
|||||||
|
|
||||||
func TestConntrackCacheTicker_Get_TextFormat(t *testing.T) {
|
func TestConntrackCacheTicker_Get_TextFormat(t *testing.T) {
|
||||||
buf := &bytes.Buffer{}
|
buf := &bytes.Buffer{}
|
||||||
l := test.NewLoggerWithOutputAndLevel(buf, logging.LevelTrace)
|
l := test.NewLoggerWithOutputAndLevel(buf, slog.LevelDebug)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 3)
|
c := newFixedTicker(t, l, 3)
|
||||||
c.Get()
|
c.Get()
|
||||||
|
|
||||||
assert.Equal(t, "level=DEBUG-4 msg=\"resetting conntrack cache\" len=3\n", buf.String())
|
assert.Equal(t, "level=DEBUG msg=\"resetting conntrack cache\" len=3\n", buf.String())
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestConntrackCacheTicker_Get_JSONFormat(t *testing.T) {
|
func TestConntrackCacheTicker_Get_JSONFormat(t *testing.T) {
|
||||||
buf := &bytes.Buffer{}
|
buf := &bytes.Buffer{}
|
||||||
l := test.NewJSONLoggerWithOutput(buf, logging.LevelTrace)
|
l := test.NewJSONLoggerWithOutput(buf, slog.LevelDebug)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 2)
|
c := newFixedTicker(t, l, 2)
|
||||||
c.Get()
|
c.Get()
|
||||||
|
|
||||||
assert.JSONEq(t, `{"level":"DEBUG-4","msg":"resetting conntrack cache","len":2}`, strings.TrimSpace(buf.String()))
|
assert.JSONEq(t, `{"level":"DEBUG","msg":"resetting conntrack cache","len":2}`, strings.TrimSpace(buf.String()))
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestConntrackCacheTicker_Get_QuietBelowTrace(t *testing.T) {
|
func TestConntrackCacheTicker_Get_QuietBelowDebug(t *testing.T) {
|
||||||
buf := &bytes.Buffer{}
|
buf := &bytes.Buffer{}
|
||||||
l := test.NewLoggerWithOutputAndLevel(buf, slog.LevelDebug)
|
l := test.NewLoggerWithOutputAndLevel(buf, slog.LevelInfo)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 5)
|
c := newFixedTicker(t, l, 5)
|
||||||
c.Get()
|
c.Get()
|
||||||
@@ -61,7 +60,7 @@ func TestConntrackCacheTicker_Get_QuietBelowTrace(t *testing.T) {
|
|||||||
|
|
||||||
func TestConntrackCacheTicker_Get_QuietWhenCacheEmpty(t *testing.T) {
|
func TestConntrackCacheTicker_Get_QuietWhenCacheEmpty(t *testing.T) {
|
||||||
buf := &bytes.Buffer{}
|
buf := &bytes.Buffer{}
|
||||||
l := test.NewLoggerWithOutputAndLevel(buf, logging.LevelTrace)
|
l := test.NewLoggerWithOutputAndLevel(buf, slog.LevelDebug)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 0)
|
c := newFixedTicker(t, l, 0)
|
||||||
c.Get()
|
c.Get()
|
||||||
|
|||||||
+9
-15
@@ -4,14 +4,17 @@ import (
|
|||||||
"encoding/json"
|
"encoding/json"
|
||||||
"fmt"
|
"fmt"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/iputil"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
type m = map[string]any
|
type m = map[string]any
|
||||||
|
|
||||||
const (
|
const (
|
||||||
ProtoAny = 0 // When we want to handle HOPOPT (0) we can change this, if ever
|
ProtoAny = 0 // When we want to handle HOPOPT (0) we can change this, if ever
|
||||||
|
ProtoTCP = 6
|
||||||
|
ProtoUDP = 17
|
||||||
|
ProtoICMP = 1
|
||||||
|
ProtoICMPv6 = 58
|
||||||
|
|
||||||
PortAny = 0 // Special value for matching `port: any`
|
PortAny = 0 // Special value for matching `port: any`
|
||||||
PortFragment = -1 // Special value for matching `port: fragment`
|
PortFragment = -1 // Special value for matching `port: fragment`
|
||||||
)
|
)
|
||||||
@@ -42,13 +45,13 @@ func (fp *Packet) Copy() *Packet {
|
|||||||
func (fp Packet) MarshalJSON() ([]byte, error) {
|
func (fp Packet) MarshalJSON() ([]byte, error) {
|
||||||
var proto string
|
var proto string
|
||||||
switch fp.Protocol {
|
switch fp.Protocol {
|
||||||
case iputil.IPProtocolTCP:
|
case ProtoTCP:
|
||||||
proto = "tcp"
|
proto = "tcp"
|
||||||
case iputil.IPProtocolICMP:
|
case ProtoICMP:
|
||||||
proto = "icmp"
|
proto = "icmp"
|
||||||
case iputil.IPProtocolICMPv6:
|
case ProtoICMPv6:
|
||||||
proto = "icmpv6"
|
proto = "icmpv6"
|
||||||
case iputil.IPProtocolUDP:
|
case ProtoUDP:
|
||||||
proto = "udp"
|
proto = "udp"
|
||||||
default:
|
default:
|
||||||
proto = fmt.Sprintf("unknown %v", fp.Protocol)
|
proto = fmt.Sprintf("unknown %v", fp.Protocol)
|
||||||
@@ -62,12 +65,3 @@ func (fp Packet) MarshalJSON() ([]byte, error) {
|
|||||||
"Fragment": fp.Fragment,
|
"Fragment": fp.Fragment,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
// ParsedPacket is a Packet plus the parse byproducts the RX path reuses
|
|
||||||
type ParsedPacket struct {
|
|
||||||
Packet
|
|
||||||
IPHdrLen int
|
|
||||||
// FragAny reports any fragmentation at all: MF flag or nonzero offset for IPv4, a fragment extension header for IPv6.
|
|
||||||
// Distinct from Packet.Fragment, which is true only for NON-FIRST fragments
|
|
||||||
FragAny bool
|
|
||||||
}
|
|
||||||
+33
-34
@@ -13,7 +13,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/firewall"
|
"github.com/slackhq/nebula/firewall"
|
||||||
"github.com/slackhq/nebula/iputil"
|
|
||||||
"github.com/slackhq/nebula/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
@@ -73,20 +72,20 @@ func TestFirewall_AddRule(t *testing.T) {
|
|||||||
ti6, err := netip.ParsePrefix("fd12::34/128")
|
ti6, err := netip.ParsePrefix("fd12::34/128")
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
|
|
||||||
require.NoError(t, fw.AddRule(true, iputil.IPProtocolTCP, 1, 1, []string{}, "", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, firewall.ProtoTCP, 1, 1, []string{}, "", "", "", "", ""))
|
||||||
// An empty rule is any
|
// An empty rule is any
|
||||||
assert.True(t, fw.InRules.TCP[1].Any.Any.Any)
|
assert.True(t, fw.InRules.TCP[1].Any.Any.Any)
|
||||||
assert.Empty(t, fw.InRules.TCP[1].Any.Groups)
|
assert.Empty(t, fw.InRules.TCP[1].Any.Groups)
|
||||||
assert.Empty(t, fw.InRules.TCP[1].Any.Hosts)
|
assert.Empty(t, fw.InRules.TCP[1].Any.Hosts)
|
||||||
|
|
||||||
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
||||||
require.NoError(t, fw.AddRule(true, iputil.IPProtocolUDP, 1, 1, []string{"g1"}, "", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, firewall.ProtoUDP, 1, 1, []string{"g1"}, "", "", "", "", ""))
|
||||||
assert.Nil(t, fw.InRules.UDP[1].Any.Any)
|
assert.Nil(t, fw.InRules.UDP[1].Any.Any)
|
||||||
assert.Contains(t, fw.InRules.UDP[1].Any.Groups[0].Groups, "g1")
|
assert.Contains(t, fw.InRules.UDP[1].Any.Groups[0].Groups, "g1")
|
||||||
assert.Empty(t, fw.InRules.UDP[1].Any.Hosts)
|
assert.Empty(t, fw.InRules.UDP[1].Any.Hosts)
|
||||||
|
|
||||||
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
||||||
require.NoError(t, fw.AddRule(true, iputil.IPProtocolICMP, 1, 1, []string{}, "h1", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, firewall.ProtoICMP, 1, 1, []string{}, "h1", "", "", "", ""))
|
||||||
//no matter what port is given for icmp, it should end up as "any"
|
//no matter what port is given for icmp, it should end up as "any"
|
||||||
assert.Nil(t, fw.InRules.ICMP[firewall.PortAny].Any.Any)
|
assert.Nil(t, fw.InRules.ICMP[firewall.PortAny].Any.Any)
|
||||||
assert.Empty(t, fw.InRules.ICMP[firewall.PortAny].Any.Groups)
|
assert.Empty(t, fw.InRules.ICMP[firewall.PortAny].Any.Groups)
|
||||||
@@ -117,11 +116,11 @@ func TestFirewall_AddRule(t *testing.T) {
|
|||||||
assert.True(t, ok)
|
assert.True(t, ok)
|
||||||
|
|
||||||
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
||||||
require.NoError(t, fw.AddRule(true, iputil.IPProtocolUDP, 1, 1, []string{"g1"}, "", "", "", "ca-name", ""))
|
require.NoError(t, fw.AddRule(true, firewall.ProtoUDP, 1, 1, []string{"g1"}, "", "", "", "ca-name", ""))
|
||||||
assert.Contains(t, fw.InRules.UDP[1].CANames, "ca-name")
|
assert.Contains(t, fw.InRules.UDP[1].CANames, "ca-name")
|
||||||
|
|
||||||
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
||||||
require.NoError(t, fw.AddRule(true, iputil.IPProtocolUDP, 1, 1, []string{"g1"}, "", "", "", "", "ca-sha"))
|
require.NoError(t, fw.AddRule(true, firewall.ProtoUDP, 1, 1, []string{"g1"}, "", "", "", "", "ca-sha"))
|
||||||
assert.Contains(t, fw.InRules.UDP[1].CAShas, "ca-sha")
|
assert.Contains(t, fw.InRules.UDP[1].CAShas, "ca-sha")
|
||||||
|
|
||||||
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
fw = NewFirewall(l, time.Second, time.Minute, time.Hour, c)
|
||||||
@@ -186,7 +185,7 @@ func TestFirewall_Drop(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
||||||
LocalPort: 10,
|
LocalPort: 10,
|
||||||
RemotePort: 90,
|
RemotePort: 90,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -264,7 +263,7 @@ func TestFirewall_DropV6(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("fd12::34"),
|
RemoteAddr: netip.MustParseAddr("fd12::34"),
|
||||||
LocalPort: 10,
|
LocalPort: 10,
|
||||||
RemotePort: 90,
|
RemotePort: 90,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -351,7 +350,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
Certificate: &dummyCert{},
|
Certificate: &dummyCert{},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolUDP}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoUDP}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -361,7 +360,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
Certificate: &dummyCert{},
|
Certificate: &dummyCert{},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 1}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 1}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -371,7 +370,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
}
|
}
|
||||||
ip := netip.MustParsePrefix("9.254.254.254/32")
|
ip := netip.MustParsePrefix("9.254.254.254/32")
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: ip.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 100, LocalAddr: ip.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
b.Run("pass proto, port, fail on local CIDRv6", func(b *testing.B) {
|
b.Run("pass proto, port, fail on local CIDRv6", func(b *testing.B) {
|
||||||
@@ -380,7 +379,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
}
|
}
|
||||||
ip := netip.MustParsePrefix("fd99::99/128")
|
ip := netip.MustParsePrefix("fd99::99/128")
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: ip.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 100, LocalAddr: ip.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -393,7 +392,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"nope": {}},
|
InvertedGroups: map[string]struct{}{"nope": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 10}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 10}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
b.Run("pass proto, port, any local CIDRv6, fail all group, name, and cidr", func(b *testing.B) {
|
b.Run("pass proto, port, any local CIDRv6, fail all group, name, and cidr", func(b *testing.B) {
|
||||||
@@ -405,7 +404,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"nope": {}},
|
InvertedGroups: map[string]struct{}{"nope": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 10}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 10}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -418,7 +417,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"nope": {}},
|
InvertedGroups: map[string]struct{}{"nope": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: pfix.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
b.Run("pass proto, port, specific local CIDRv6, fail all group, name, and cidr", func(b *testing.B) {
|
b.Run("pass proto, port, specific local CIDRv6, fail all group, name, and cidr", func(b *testing.B) {
|
||||||
@@ -430,7 +429,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"nope": {}},
|
InvertedGroups: map[string]struct{}{"nope": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -442,7 +441,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"good-group": {}},
|
InvertedGroups: map[string]struct{}{"good-group": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.True(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 10}, true, c, cp))
|
assert.True(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 10}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -454,7 +453,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"good-group": {}},
|
InvertedGroups: map[string]struct{}{"good-group": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.True(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: pfix.Addr()}, true, c, cp))
|
assert.True(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
b.Run("pass on group on specific local cidr6", func(b *testing.B) {
|
b.Run("pass on group on specific local cidr6", func(b *testing.B) {
|
||||||
@@ -465,7 +464,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"good-group": {}},
|
InvertedGroups: map[string]struct{}{"good-group": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
assert.True(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
assert.True(b, ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -477,7 +476,7 @@ func BenchmarkFirewallTable_match(b *testing.B) {
|
|||||||
InvertedGroups: map[string]struct{}{"nope": {}},
|
InvertedGroups: map[string]struct{}{"nope": {}},
|
||||||
}
|
}
|
||||||
for n := 0; n < b.N; n++ {
|
for n := 0; n < b.N; n++ {
|
||||||
ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 10}, true, c, cp)
|
ft.match(firewall.Packet{Protocol: firewall.ProtoTCP, LocalPort: 10}, true, c, cp)
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
@@ -493,7 +492,7 @@ func TestFirewall_Drop2(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
||||||
LocalPort: 10,
|
LocalPort: 10,
|
||||||
RemotePort: 90,
|
RemotePort: 90,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -551,7 +550,7 @@ func TestFirewall_Drop3(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
||||||
LocalPort: 1,
|
LocalPort: 1,
|
||||||
RemotePort: 1,
|
RemotePort: 1,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -639,7 +638,7 @@ func TestFirewall_Drop3V6(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("fd12::34"),
|
RemoteAddr: netip.MustParseAddr("fd12::34"),
|
||||||
LocalPort: 1,
|
LocalPort: 1,
|
||||||
RemotePort: 1,
|
RemotePort: 1,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -676,7 +675,7 @@ func TestFirewall_DropConntrackReload(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
||||||
LocalPort: 10,
|
LocalPort: 10,
|
||||||
RemotePort: 90,
|
RemotePort: 90,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
network := netip.MustParsePrefix("1.2.3.4/24")
|
network := netip.MustParsePrefix("1.2.3.4/24")
|
||||||
@@ -759,13 +758,13 @@ func TestFirewall_ICMPPortBehavior(t *testing.T) {
|
|||||||
templ := firewall.Packet{
|
templ := firewall.Packet{
|
||||||
LocalAddr: netip.MustParseAddr("1.2.3.4"),
|
LocalAddr: netip.MustParseAddr("1.2.3.4"),
|
||||||
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
RemoteAddr: netip.MustParseAddr("1.2.3.4"),
|
||||||
Protocol: iputil.IPProtocolICMP,
|
Protocol: firewall.ProtoICMP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
t.Run("ICMP allowed", func(t *testing.T) {
|
t.Run("ICMP allowed", func(t *testing.T) {
|
||||||
fw := NewFirewall(l, time.Second, time.Minute, time.Hour, c.Certificate)
|
fw := NewFirewall(l, time.Second, time.Minute, time.Hour, c.Certificate)
|
||||||
require.NoError(t, fw.AddRule(true, iputil.IPProtocolICMP, 0, 0, []string{"any"}, "", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, firewall.ProtoICMP, 0, 0, []string{"any"}, "", "", "", "", ""))
|
||||||
t.Run("zero ports", func(t *testing.T) {
|
t.Run("zero ports", func(t *testing.T) {
|
||||||
p := templ.Copy()
|
p := templ.Copy()
|
||||||
p.LocalPort = 0
|
p.LocalPort = 0
|
||||||
@@ -911,7 +910,7 @@ func TestFirewall_DropIPSpoofing(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("192.0.2.3"),
|
RemoteAddr: netip.MustParseAddr("192.0.2.3"),
|
||||||
LocalPort: 1,
|
LocalPort: 1,
|
||||||
RemotePort: 1,
|
RemotePort: 1,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
assert.Equal(t, fw.Drop(p, true, &h1, cp, nil), ErrInvalidRemoteIP)
|
assert.Equal(t, fw.Drop(p, true, &h1, cp, nil), ErrInvalidRemoteIP)
|
||||||
@@ -962,7 +961,7 @@ func TestFirewall_ConntrackSourceSpoofingAcrossPeers(t *testing.T) {
|
|||||||
RemoteAddr: netip.MustParseAddr("192.0.2.2"),
|
RemoteAddr: netip.MustParseAddr("192.0.2.2"),
|
||||||
LocalPort: 443,
|
LocalPort: 443,
|
||||||
RemotePort: 55000,
|
RemotePort: 55000,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
}
|
}
|
||||||
|
|
||||||
require.NoError(t, fw.Drop(flow, true, &victimHI, cp, nil),
|
require.NoError(t, fw.Drop(flow, true, &victimHI, cp, nil),
|
||||||
@@ -1032,7 +1031,7 @@ func BenchmarkFirewallDropConntrackHit(b *testing.B) {
|
|||||||
RemoteAddr: netip.MustParseAddr("192.0.2.2"),
|
RemoteAddr: netip.MustParseAddr("192.0.2.2"),
|
||||||
LocalPort: 443,
|
LocalPort: 443,
|
||||||
RemotePort: 55000,
|
RemotePort: 55000,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
}
|
}
|
||||||
|
|
||||||
cases := []struct {
|
cases := []struct {
|
||||||
@@ -1318,28 +1317,28 @@ func TestAddFirewallRulesFromConfig(t *testing.T) {
|
|||||||
mf := &mockFirewall{}
|
mf := &mockFirewall{}
|
||||||
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"port": "1", "proto": "tcp", "host": "a"}}}
|
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"port": "1", "proto": "tcp", "host": "a"}}}
|
||||||
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
||||||
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolTCP, startPort: 1, endPort: 1, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: firewall.ProtoTCP, startPort: 1, endPort: 1, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
||||||
|
|
||||||
// Test adding udp rule
|
// Test adding udp rule
|
||||||
conf = config.NewC(test.NewLogger())
|
conf = config.NewC(test.NewLogger())
|
||||||
mf = &mockFirewall{}
|
mf = &mockFirewall{}
|
||||||
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"port": "1", "proto": "udp", "host": "a"}}}
|
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"port": "1", "proto": "udp", "host": "a"}}}
|
||||||
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
||||||
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolUDP, startPort: 1, endPort: 1, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: firewall.ProtoUDP, startPort: 1, endPort: 1, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
||||||
|
|
||||||
// Test adding icmp rule
|
// Test adding icmp rule
|
||||||
conf = config.NewC(test.NewLogger())
|
conf = config.NewC(test.NewLogger())
|
||||||
mf = &mockFirewall{}
|
mf = &mockFirewall{}
|
||||||
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"port": "1", "proto": "icmp", "host": "a"}}}
|
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"port": "1", "proto": "icmp", "host": "a"}}}
|
||||||
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
||||||
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolICMP, startPort: firewall.PortAny, endPort: firewall.PortAny, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: firewall.ProtoICMP, startPort: firewall.PortAny, endPort: firewall.PortAny, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
||||||
|
|
||||||
// Test adding icmp rule no port
|
// Test adding icmp rule no port
|
||||||
conf = config.NewC(test.NewLogger())
|
conf = config.NewC(test.NewLogger())
|
||||||
mf = &mockFirewall{}
|
mf = &mockFirewall{}
|
||||||
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"proto": "icmp", "host": "a"}}}
|
conf.Settings["firewall"] = map[string]any{"outbound": []any{map[string]any{"proto": "icmp", "host": "a"}}}
|
||||||
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
require.NoError(t, AddFirewallRulesFromConfig(l, false, conf, mf))
|
||||||
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolICMP, startPort: firewall.PortAny, endPort: firewall.PortAny, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: firewall.ProtoICMP, startPort: firewall.PortAny, endPort: firewall.PortAny, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
||||||
|
|
||||||
// Test adding any rule
|
// Test adding any rule
|
||||||
conf = config.NewC(test.NewLogger())
|
conf = config.NewC(test.NewLogger())
|
||||||
@@ -1583,7 +1582,7 @@ func buildTestCase(setup testsetup, err error, theirPrefixes ...netip.Prefix) te
|
|||||||
RemoteAddr: theirPrefixes[0].Addr(),
|
RemoteAddr: theirPrefixes[0].Addr(),
|
||||||
LocalPort: 10,
|
LocalPort: 10,
|
||||||
RemotePort: 90,
|
RemotePort: 90,
|
||||||
Protocol: iputil.IPProtocolUDP,
|
Protocol: firewall.ProtoUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
return testcase{
|
return testcase{
|
||||||
|
|||||||
@@ -5,33 +5,34 @@ 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
|
||||||
github.com/gaissmai/bart v0.29.0
|
github.com/gaissmai/bart v0.28.0
|
||||||
github.com/gogo/protobuf v1.3.2
|
github.com/gogo/protobuf v1.3.2
|
||||||
github.com/google/gopacket v1.1.19
|
github.com/google/gopacket v1.1.19
|
||||||
github.com/kardianos/service v1.3.0
|
github.com/kardianos/service v1.3.0
|
||||||
github.com/miekg/dns v1.1.73
|
github.com/miekg/dns v1.1.72
|
||||||
github.com/miekg/pkcs11 v1.1.2
|
github.com/miekg/pkcs11 v1.1.2
|
||||||
github.com/nbrownus/go-metrics-prometheus v0.0.0-20210712211119-974a6260965f
|
github.com/nbrownus/go-metrics-prometheus v0.0.0-20210712211119-974a6260965f
|
||||||
github.com/prometheus/client_golang v1.24.1
|
github.com/prometheus/client_golang v1.23.2
|
||||||
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475
|
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475
|
||||||
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.12.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.5
|
go.yaml.in/yaml/v3 v3.0.4
|
||||||
golang.org/x/crypto v0.57.0
|
golang.org/x/crypto v0.54.0
|
||||||
golang.org/x/net v0.59.0
|
golang.org/x/exp v0.0.0-20230725093048-515e97ebf090
|
||||||
golang.org/x/sync v0.23.0
|
golang.org/x/net v0.57.0
|
||||||
golang.org/x/sys v0.48.0
|
golang.org/x/sync v0.22.0
|
||||||
golang.org/x/term v0.46.0
|
golang.org/x/sys v0.47.0
|
||||||
|
golang.org/x/term v0.45.0
|
||||||
golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2
|
golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2
|
||||||
golang.zx2c4.com/wireguard v0.0.0-20230325221338-052af4a8072b
|
golang.zx2c4.com/wireguard v0.0.0-20230325221338-052af4a8072b
|
||||||
golang.zx2c4.com/wireguard/windows v1.0.1
|
golang.zx2c4.com/wireguard/windows v1.0.1
|
||||||
google.golang.org/protobuf v1.36.12
|
google.golang.org/protobuf v1.36.11
|
||||||
gopkg.in/yaml.v3 v3.0.1
|
gopkg.in/yaml.v3 v3.0.1
|
||||||
gvisor.dev/gvisor v0.0.0-20240423190808-9d7a357edefe
|
gvisor.dev/gvisor v0.0.0-20240423190808-9d7a357edefe
|
||||||
)
|
)
|
||||||
@@ -39,11 +40,16 @@ require (
|
|||||||
require (
|
require (
|
||||||
github.com/beorn7/perks v1.0.1 // indirect
|
github.com/beorn7/perks v1.0.1 // indirect
|
||||||
github.com/cespare/xxhash/v2 v2.3.0 // indirect
|
github.com/cespare/xxhash/v2 v2.3.0 // indirect
|
||||||
|
github.com/davecgh/go-spew v1.1.1 // indirect
|
||||||
github.com/google/btree v1.1.2 // indirect
|
github.com/google/btree v1.1.2 // indirect
|
||||||
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
|
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
|
||||||
|
github.com/pmezard/go-difflib v1.0.0 // indirect
|
||||||
github.com/prometheus/client_model v0.6.2 // indirect
|
github.com/prometheus/client_model v0.6.2 // indirect
|
||||||
github.com/prometheus/common v0.70.1 // indirect
|
github.com/prometheus/common v0.66.1 // indirect
|
||||||
github.com/prometheus/procfs v0.21.1 // indirect
|
github.com/prometheus/procfs v0.16.1 // indirect
|
||||||
github.com/vishvananda/netns v0.0.5 // indirect
|
github.com/vishvananda/netns v0.0.5 // indirect
|
||||||
|
go.yaml.in/yaml/v2 v2.4.2 // indirect
|
||||||
|
golang.org/x/mod v0.36.0 // indirect
|
||||||
golang.org/x/time v0.5.0 // indirect
|
golang.org/x/time v0.5.0 // indirect
|
||||||
|
golang.org/x/tools v0.45.0 // indirect
|
||||||
)
|
)
|
||||||
@@ -3,8 +3,6 @@ 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=
|
||||||
@@ -22,11 +20,12 @@ github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL
|
|||||||
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
|
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
|
||||||
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||||
|
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||||
github.com/flynn/noise v1.1.0 h1:KjPQoQCEFdZDiP03phOvGi11+SVVhBG2wOWAorLsstg=
|
github.com/flynn/noise v1.1.0 h1:KjPQoQCEFdZDiP03phOvGi11+SVVhBG2wOWAorLsstg=
|
||||||
github.com/flynn/noise v1.1.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag=
|
github.com/flynn/noise v1.1.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag=
|
||||||
github.com/gaissmai/bart v0.29.0 h1:wO6HGE8g9YE0Wm0bCpYxwRzfQ4+fbJKOhL64e5ACGCI=
|
github.com/gaissmai/bart v0.28.0 h1:89yZLo8NmyqD0RYgJ3QO9HhqqGGw+oWhf90cZm69Lko=
|
||||||
github.com/gaissmai/bart v0.29.0/go.mod h1:GREWQfTLRWz/c5FTOsIw+KkscuFkIV5t8Rp7Nd1Td5c=
|
github.com/gaissmai/bart v0.28.0/go.mod h1:GREWQfTLRWz/c5FTOsIw+KkscuFkIV5t8Rp7Nd1Td5c=
|
||||||
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
|
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
|
||||||
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
|
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
|
||||||
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
|
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
|
||||||
@@ -69,22 +68,23 @@ github.com/kardianos/service v1.3.0 h1:/LGy+xPP2TM+GLTiCZ2di7cy0Jd/qrawlTUfqKYFd
|
|||||||
github.com/kardianos/service v1.3.0/go.mod h1:E4V9ufUuY82F7Ztlu1eN9VXWIQxg8NoLQlmFe0MtrXc=
|
github.com/kardianos/service v1.3.0/go.mod h1:E4V9ufUuY82F7Ztlu1eN9VXWIQxg8NoLQlmFe0MtrXc=
|
||||||
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
|
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
|
||||||
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
|
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
|
||||||
github.com/klauspost/compress v1.19.1 h1:VsB4HPswih7mmZ8WleSFQ75c/Ui1M4trX5oAsJnhSlk=
|
github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
|
||||||
github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
|
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
|
||||||
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
|
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
|
||||||
github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
|
github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
|
||||||
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
|
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
|
||||||
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
|
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
|
||||||
github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
|
|
||||||
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
|
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
|
||||||
|
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
|
||||||
|
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
|
||||||
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
|
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
|
||||||
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
|
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
|
||||||
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
|
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
|
||||||
github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
|
github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
|
||||||
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
|
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
|
||||||
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
|
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
|
||||||
github.com/miekg/dns v1.1.73 h1:uhT8nJxmTrPJYClxVxTCX+CVn6qnzSiybRk72Z6DgrE=
|
github.com/miekg/dns v1.1.72 h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI=
|
||||||
github.com/miekg/dns v1.1.73/go.mod h1:RW2Obtfd5NZHvOFe3zYG0W8koWOQtAzyHaLo8vASBuQ=
|
github.com/miekg/dns v1.1.72/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
|
||||||
github.com/miekg/pkcs11 v1.1.2 h1:/VxmeAX5qU6Q3EwafypogwWbYryHFmF2RpkJmw3m4MQ=
|
github.com/miekg/pkcs11 v1.1.2 h1:/VxmeAX5qU6Q3EwafypogwWbYryHFmF2RpkJmw3m4MQ=
|
||||||
github.com/miekg/pkcs11 v1.1.2/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs=
|
github.com/miekg/pkcs11 v1.1.2/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs=
|
||||||
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
|
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
|
||||||
@@ -100,13 +100,14 @@ github.com/nbrownus/go-metrics-prometheus v0.0.0-20210712211119-974a6260965f/go.
|
|||||||
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
||||||
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
||||||
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
||||||
|
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||||
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
|
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
|
||||||
github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
|
github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
|
||||||
github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
|
github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
|
||||||
github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
|
github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
|
||||||
github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU=
|
github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
|
||||||
github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE=
|
github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
|
||||||
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
|
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
|
||||||
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
|
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
|
||||||
github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
|
github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
|
||||||
@@ -115,16 +116,18 @@ github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvM
|
|||||||
github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
|
github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
|
||||||
github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
|
github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
|
||||||
github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
|
github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
|
||||||
github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY=
|
github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
|
||||||
github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc=
|
github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
|
||||||
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
|
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
|
||||||
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
|
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
|
||||||
github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
|
github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
|
||||||
github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
|
github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
|
||||||
github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI=
|
github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
|
||||||
github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
|
github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
|
||||||
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM=
|
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM=
|
||||||
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
|
github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
|
||||||
|
github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
|
||||||
|
github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
|
||||||
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
|
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
|
||||||
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
|
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
|
||||||
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
|
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
|
||||||
@@ -138,29 +141,35 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
|
|||||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||||
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
|
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
|
||||||
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.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
|
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
|
||||||
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
|
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=
|
||||||
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
|
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
|
||||||
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
|
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
|
||||||
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
|
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
|
||||||
go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
|
go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
|
||||||
go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
|
go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
|
||||||
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
|
go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
|
||||||
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
|
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
|
||||||
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
|
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
|
||||||
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
|
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
|
||||||
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
|
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
|
||||||
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
|
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
|
||||||
golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
|
golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
|
||||||
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
|
golang.org/x/crypto v0.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
|
||||||
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
|
golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
|
||||||
|
golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 h1:Di6/M8l0O2lCLc6VVRWhgCiApHV8MnQurBnFSHsQtNY=
|
||||||
|
golang.org/x/exp v0.0.0-20230725093048-515e97ebf090/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
|
||||||
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
|
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
|
||||||
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
|
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
|
||||||
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
|
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
|
||||||
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
|
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
|
||||||
|
golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4=
|
||||||
|
golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ=
|
||||||
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||||
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||||
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
|
||||||
@@ -171,8 +180,8 @@ golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLL
|
|||||||
golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
|
golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
|
||||||
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
|
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
|
||||||
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
|
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
|
||||||
golang.org/x/net v0.59.0 h1:5zfYln+w5XCxwrnMMJPufRgNoXEaGxl0wo5GqPXyues=
|
golang.org/x/net v0.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
|
||||||
golang.org/x/net v0.59.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
|
golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
|
||||||
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
|
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
|
||||||
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||||
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||||
@@ -180,8 +189,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
|
|||||||
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||||
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||||
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||||
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
|
golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
|
||||||
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
|
||||||
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||||
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||||
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||||
@@ -195,11 +204,13 @@ 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.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
|
golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||||
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
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/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=
|
||||||
golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE=
|
golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0=
|
||||||
golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc=
|
golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w=
|
||||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||||
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
|
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
|
||||||
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||||
@@ -210,6 +221,8 @@ golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtn
|
|||||||
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
|
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
|
||||||
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
|
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
|
||||||
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
|
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
|
||||||
|
golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8=
|
||||||
|
golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0=
|
||||||
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||||
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||||
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||||
@@ -228,8 +241,8 @@ google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miE
|
|||||||
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
|
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
|
||||||
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
|
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
|
||||||
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
|
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
|
||||||
google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=
|
google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
|
||||||
google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
|
google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
|
||||||
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
|
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
|
||||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||||
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||||
|
|||||||
+5
-18
@@ -31,7 +31,6 @@ package nebula
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"bufio"
|
"bufio"
|
||||||
"context"
|
|
||||||
"fmt"
|
"fmt"
|
||||||
"net"
|
"net"
|
||||||
"strconv"
|
"strconv"
|
||||||
@@ -52,29 +51,17 @@ type graphiteConfigExport struct {
|
|||||||
Percentiles []float64 // Percentiles to export from timers and histograms
|
Percentiles []float64 // Percentiles to export from timers and histograms
|
||||||
}
|
}
|
||||||
|
|
||||||
// graphiteTimeout bounds one submission, the connect and the write together. An export is a few KB, a host that can't
|
|
||||||
// take that in this long isn't going to.
|
|
||||||
const graphiteTimeout = 30 * time.Second
|
|
||||||
|
|
||||||
// graphiteOnce performs a single submission to Graphite, returning a non-nil
|
// graphiteOnce performs a single submission to Graphite, returning a non-nil
|
||||||
// error if it could not connect or write all of it within timeout. It gives up
|
// error on failed connections.
|
||||||
// as soon as ctx is done.
|
func graphiteOnce(c graphiteConfigExport) error {
|
||||||
func graphiteOnce(ctx context.Context, c graphiteConfigExport, timeout time.Duration) error {
|
|
||||||
now := time.Now().Unix()
|
now := time.Now().Unix()
|
||||||
du := float64(c.DurationUnit)
|
du := float64(c.DurationUnit)
|
||||||
flushSeconds := float64(c.FlushInterval) / float64(time.Second)
|
flushSeconds := float64(c.FlushInterval) / float64(time.Second)
|
||||||
deadline := time.Now().Add(timeout)
|
conn, err := net.DialTCP("tcp", nil, c.Addr)
|
||||||
d := net.Dialer{Deadline: deadline}
|
|
||||||
conn, err := d.DialContext(ctx, "tcp", c.Addr.String())
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
defer conn.Close()
|
defer conn.Close()
|
||||||
if err := conn.SetDeadline(deadline); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
stop := context.AfterFunc(ctx, func() { _ = conn.Close() })
|
|
||||||
defer stop()
|
|
||||||
w := bufio.NewWriter(conn)
|
w := bufio.NewWriter(conn)
|
||||||
c.Registry.Each(func(name string, i any) {
|
c.Registry.Each(func(name string, i any) {
|
||||||
switch metric := i.(type) {
|
switch metric := i.(type) {
|
||||||
@@ -124,7 +111,7 @@ func graphiteOnce(ctx context.Context, c graphiteConfigExport, timeout time.Dura
|
|||||||
fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", c.Prefix, name, t.Rate15(), now)
|
fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", c.Prefix, name, t.Rate15(), now)
|
||||||
fmt.Fprintf(w, "%s.%s.mean-rate %.2f %d\n", c.Prefix, name, t.RateMean(), now)
|
fmt.Fprintf(w, "%s.%s.mean-rate %.2f %d\n", c.Prefix, name, t.RateMean(), now)
|
||||||
}
|
}
|
||||||
|
w.Flush()
|
||||||
})
|
})
|
||||||
// A failed write sticks, so this reports the first one
|
return nil
|
||||||
return w.Flush()
|
|
||||||
}
|
}
|
||||||
@@ -1,315 +0,0 @@
|
|||||||
package nebula
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"context"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"net"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/rcrowley/go-metrics"
|
|
||||||
"github.com/slackhq/nebula/test"
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
)
|
|
||||||
|
|
||||||
// graphiteHost accepts connections and hands each one to the test
|
|
||||||
type graphiteHost struct {
|
|
||||||
ln net.Listener
|
|
||||||
conns chan net.Conn
|
|
||||||
|
|
||||||
mu sync.Mutex
|
|
||||||
closed bool
|
|
||||||
open []net.Conn
|
|
||||||
}
|
|
||||||
|
|
||||||
// newGraphiteHost accepts connections for the test. A non-zero window shrinks each connection's receive buffer, so a
|
|
||||||
// sender that is not read from blocks after a little whatever the host's TCP tuning. Only for tests that need a stall,
|
|
||||||
// a small window makes reading very slow on Linux.
|
|
||||||
func newGraphiteHost(t *testing.T, window int) *graphiteHost {
|
|
||||||
t.Helper()
|
|
||||||
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
|
||||||
require.NoError(t, err)
|
|
||||||
h := &graphiteHost{ln: ln, conns: make(chan net.Conn, 8)}
|
|
||||||
done := make(chan struct{})
|
|
||||||
t.Cleanup(func() {
|
|
||||||
_ = ln.Close()
|
|
||||||
h.mu.Lock()
|
|
||||||
h.closed = true
|
|
||||||
for _, c := range h.open {
|
|
||||||
_ = c.Close()
|
|
||||||
}
|
|
||||||
h.mu.Unlock()
|
|
||||||
close(done)
|
|
||||||
})
|
|
||||||
go func() {
|
|
||||||
for {
|
|
||||||
c, err := ln.Accept()
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
h.mu.Lock()
|
|
||||||
if h.closed {
|
|
||||||
h.mu.Unlock()
|
|
||||||
_ = c.Close()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
h.open = append(h.open, c)
|
|
||||||
h.mu.Unlock()
|
|
||||||
if tc, ok := c.(*net.TCPConn); ok && window > 0 {
|
|
||||||
_ = tc.SetReadBuffer(window)
|
|
||||||
}
|
|
||||||
select {
|
|
||||||
case h.conns <- c:
|
|
||||||
case <-done:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
return h
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *graphiteHost) addr(t *testing.T) *net.TCPAddr {
|
|
||||||
a, err := net.ResolveTCPAddr("tcp", h.ln.Addr().String())
|
|
||||||
require.NoError(t, err)
|
|
||||||
return a
|
|
||||||
}
|
|
||||||
|
|
||||||
// readExport reads what one send wrote, bounded so a send that never finishes fails the test rather than hanging it
|
|
||||||
func readExport(t *testing.T, c net.Conn) []byte {
|
|
||||||
t.Helper()
|
|
||||||
require.NoError(t, c.SetReadDeadline(time.Now().Add(10*time.Second)))
|
|
||||||
b, err := io.ReadAll(c)
|
|
||||||
require.NoError(t, err)
|
|
||||||
return b
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *graphiteHost) next(t *testing.T, wait time.Duration) net.Conn {
|
|
||||||
t.Helper()
|
|
||||||
select {
|
|
||||||
case c := <-h.conns:
|
|
||||||
return c
|
|
||||||
case <-time.After(wait):
|
|
||||||
t.Fatal("no connection")
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// lockedBuffer is a log destination a test can read while the code under test writes to it from another goroutine
|
|
||||||
type lockedBuffer struct {
|
|
||||||
mu sync.Mutex
|
|
||||||
buf bytes.Buffer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (b *lockedBuffer) Write(p []byte) (int, error) {
|
|
||||||
b.mu.Lock()
|
|
||||||
defer b.mu.Unlock()
|
|
||||||
return b.buf.Write(p)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (b *lockedBuffer) String() string {
|
|
||||||
b.mu.Lock()
|
|
||||||
defer b.mu.Unlock()
|
|
||||||
return b.buf.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
func testGraphiteConfig(addr *net.TCPAddr, r metrics.Registry) graphiteConfigExport {
|
|
||||||
return graphiteConfigExport{Addr: addr, Registry: r, FlushInterval: time.Second, DurationUnit: time.Nanosecond, Prefix: "nebula"}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Enough metrics that one export overflows the socket buffers on any platform, so a send to a host that stops
|
|
||||||
// reading blocks
|
|
||||||
func bigGraphiteRegistry(r metrics.Registry, t *testing.T) {
|
|
||||||
for i := range 200000 {
|
|
||||||
name := fmt.Sprintf("big.gauge.%d", i)
|
|
||||||
metrics.GetOrRegisterGauge(name, r).Update(int64(i))
|
|
||||||
t.Cleanup(func() { r.Unregister(name) })
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraphiteOnce_sends(t *testing.T) {
|
|
||||||
r := metrics.NewRegistry()
|
|
||||||
metrics.GetOrRegisterGauge("g", r).Update(7)
|
|
||||||
metrics.GetOrRegisterCounter("c", r).Inc(3)
|
|
||||||
h := newGraphiteHost(t, 0)
|
|
||||||
|
|
||||||
require.NoError(t, graphiteOnce(t.Context(), testGraphiteConfig(h.addr(t), r), time.Minute))
|
|
||||||
b := readExport(t, h.next(t, 5*time.Second))
|
|
||||||
assert.Contains(t, string(b), "nebula.g.value 7 ")
|
|
||||||
assert.Contains(t, string(b), "nebula.c.count 3 ")
|
|
||||||
assert.Contains(t, string(b), "nebula.c.count_ps 3.00 ")
|
|
||||||
}
|
|
||||||
|
|
||||||
// A host that accepts and never reads is given up on, and the failed write is reported
|
|
||||||
func TestGraphiteOnce_stalledHostTimesOut(t *testing.T) {
|
|
||||||
r := metrics.NewRegistry()
|
|
||||||
bigGraphiteRegistry(r, t)
|
|
||||||
h := newGraphiteHost(t, 4096)
|
|
||||||
done := make(chan error, 1)
|
|
||||||
cfg := testGraphiteConfig(h.addr(t), r)
|
|
||||||
go func() { done <- graphiteOnce(t.Context(), cfg, 300*time.Millisecond) }()
|
|
||||||
h.next(t, 5*time.Second) // accepted, never read
|
|
||||||
|
|
||||||
select {
|
|
||||||
case err := <-done:
|
|
||||||
require.Error(t, err)
|
|
||||||
case <-time.After(10 * time.Second):
|
|
||||||
t.Fatal("the send did not give up on a host that stopped reading")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// The timeout covers the whole send, a host that keeps reading but too slowly is still given up on
|
|
||||||
func TestGraphiteOnce_timeoutCoversTheWholeSend(t *testing.T) {
|
|
||||||
r := metrics.NewRegistry()
|
|
||||||
bigGraphiteRegistry(r, t)
|
|
||||||
h := newGraphiteHost(t, 0)
|
|
||||||
done := make(chan error, 1)
|
|
||||||
start := time.Now()
|
|
||||||
cfg := testGraphiteConfig(h.addr(t), r)
|
|
||||||
go func() { done <- graphiteOnce(t.Context(), cfg, 500*time.Millisecond) }()
|
|
||||||
c := h.next(t, 5*time.Second)
|
|
||||||
stopReading := make(chan struct{})
|
|
||||||
defer close(stopReading)
|
|
||||||
// 32KB every 10ms keeps every write well inside the timeout, the whole export takes seconds
|
|
||||||
go func() {
|
|
||||||
buf := make([]byte, 32<<10)
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case <-stopReading:
|
|
||||||
return
|
|
||||||
case <-time.After(10 * time.Millisecond):
|
|
||||||
}
|
|
||||||
if _, err := c.Read(buf); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
select {
|
|
||||||
case err := <-done:
|
|
||||||
require.Error(t, err)
|
|
||||||
assert.Less(t, time.Since(start), 5*time.Second)
|
|
||||||
case <-time.After(10 * time.Second):
|
|
||||||
t.Fatal("a host that kept reading slowly held the send past its timeout")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGraphiteOnce_cancelledCtxDoesNotConnect(t *testing.T) {
|
|
||||||
h := newGraphiteHost(t, 0)
|
|
||||||
ctx, cancel := context.WithCancel(t.Context())
|
|
||||||
cancel()
|
|
||||||
require.Error(t, graphiteOnce(ctx, testGraphiteConfig(h.addr(t), metrics.NewRegistry()), time.Minute))
|
|
||||||
select {
|
|
||||||
case <-h.conns:
|
|
||||||
t.Fatal("connected on a cancelled ctx")
|
|
||||||
case <-time.After(200 * time.Millisecond):
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// A stop or reload abandons a stuck send rather than waiting out its timeout
|
|
||||||
func TestGraphiteOnce_cancelAbandonsSend(t *testing.T) {
|
|
||||||
r := metrics.NewRegistry()
|
|
||||||
bigGraphiteRegistry(r, t)
|
|
||||||
h := newGraphiteHost(t, 4096)
|
|
||||||
ctx, cancel := context.WithCancel(t.Context())
|
|
||||||
done := make(chan error, 1)
|
|
||||||
cfg := testGraphiteConfig(h.addr(t), r)
|
|
||||||
go func() { done <- graphiteOnce(ctx, cfg, time.Minute) }()
|
|
||||||
h.next(t, 5*time.Second)
|
|
||||||
select {
|
|
||||||
case err := <-done:
|
|
||||||
t.Fatalf("the send should be stuck on a host that is not reading, it ended with %v", err)
|
|
||||||
case <-time.After(200 * time.Millisecond):
|
|
||||||
}
|
|
||||||
|
|
||||||
cancel()
|
|
||||||
select {
|
|
||||||
case err := <-done:
|
|
||||||
require.Error(t, err)
|
|
||||||
case <-time.After(5 * time.Second):
|
|
||||||
t.Fatal("the send is still stuck after its ctx was cancelled")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// buildRuntime hands graphite the configured prefix and interval
|
|
||||||
func TestStatsServer_graphiteExportUsesConfig(t *testing.T) {
|
|
||||||
const name = "graphite.wiring.test"
|
|
||||||
metrics.GetOrRegisterCounter(name, nil).Inc(8)
|
|
||||||
t.Cleanup(func() { metrics.DefaultRegistry.Unregister(name) })
|
|
||||||
h := newGraphiteHost(t, 0)
|
|
||||||
s, c := newTestStatsServer(t)
|
|
||||||
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "4s", "prefix": "pfx", "host": h.ln.Addr().String()})
|
|
||||||
cfg, err := loadStatsConfig(c)
|
|
||||||
require.NoError(t, err)
|
|
||||||
|
|
||||||
s.runMu.Lock()
|
|
||||||
fns, _ := s.buildRuntime(t.Context(), cfg)
|
|
||||||
s.runMu.Unlock()
|
|
||||||
for _, fn := range fns {
|
|
||||||
fn()
|
|
||||||
}
|
|
||||||
b := readExport(t, h.next(t, 5*time.Second))
|
|
||||||
assert.Contains(t, string(b), "pfx."+name+".count 8 ")
|
|
||||||
assert.Contains(t, string(b), "pfx."+name+".count_ps 2.00 ")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStatsServer_graphiteFailureIsLogged(t *testing.T) {
|
|
||||||
logs := &lockedBuffer{}
|
|
||||||
s, c := newTestStatsServer(t)
|
|
||||||
s.l = test.NewLoggerWithOutput(logs)
|
|
||||||
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": "127.0.0.1:" + freeTCPPort(t)})
|
|
||||||
cfg, err := loadStatsConfig(c)
|
|
||||||
require.NoError(t, err)
|
|
||||||
|
|
||||||
s.runMu.Lock()
|
|
||||||
fns, _ := s.buildRuntime(t.Context(), cfg)
|
|
||||||
s.runMu.Unlock()
|
|
||||||
for _, fn := range fns {
|
|
||||||
fn()
|
|
||||||
}
|
|
||||||
assert.Contains(t, logs.String(), "Graphite export failed")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Stop abandons the running export, so it goes through Start rather than handing buildRuntime a ctx, and a stop is
|
|
||||||
// not logged as a failure
|
|
||||||
func TestStatsServer_stopAbandonsGraphiteSend(t *testing.T) {
|
|
||||||
bigGraphiteRegistry(metrics.DefaultRegistry, t)
|
|
||||||
h := newGraphiteHost(t, 4096)
|
|
||||||
logs := &lockedBuffer{}
|
|
||||||
s, c := newTestStatsServer(t)
|
|
||||||
s.l = test.NewLoggerWithOutput(logs)
|
|
||||||
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "50ms", "host": h.ln.Addr().String()})
|
|
||||||
require.NoError(t, s.reload(c, true))
|
|
||||||
|
|
||||||
started := make(chan struct{})
|
|
||||||
go func() {
|
|
||||||
s.Start()
|
|
||||||
close(started)
|
|
||||||
}()
|
|
||||||
stuck := h.next(t, 30*time.Second)
|
|
||||||
s.Stop()
|
|
||||||
select {
|
|
||||||
case <-started:
|
|
||||||
case <-time.After(5 * time.Second):
|
|
||||||
t.Fatal("Start did not return after Stop")
|
|
||||||
}
|
|
||||||
|
|
||||||
// A closed sender resets the connection once it sees this, one still sending just buffers it. Either way the
|
|
||||||
// read below doesn't have to drain the export through the small window to find out
|
|
||||||
_, err := stuck.Write([]byte("x"))
|
|
||||||
require.NoError(t, err)
|
|
||||||
require.NoError(t, stuck.SetReadDeadline(time.Now().Add(10*time.Second)))
|
|
||||||
n, err := io.Copy(io.Discard, stuck)
|
|
||||||
var ne net.Error
|
|
||||||
if errors.As(err, &ne) && ne.Timeout() {
|
|
||||||
t.Fatalf("the send kept the connection after Stop, read %d bytes", n)
|
|
||||||
}
|
|
||||||
assert.Less(t, n, int64(1<<20), "the send kept going after Stop")
|
|
||||||
// The capture loop logs on its own goroutine after Start has returned, give it the chance
|
|
||||||
assert.Never(t, func() bool { return strings.Contains(logs.String(), "Graphite export failed") }, 500*time.Millisecond, 10*time.Millisecond, "a stop is not a failure")
|
|
||||||
}
|
|
||||||
+12
-12
@@ -54,8 +54,7 @@ type HandshakeConfig struct {
|
|||||||
}
|
}
|
||||||
|
|
||||||
type HandshakeManager struct {
|
type HandshakeManager struct {
|
||||||
// Mutex for interacting with the vpnIps and indexes maps.
|
// Mutex for interacting with the vpnIps and indexes maps
|
||||||
// Lock order is hostmap, then this lock, then the lighthouse, then a RemoteList.
|
|
||||||
sync.RWMutex
|
sync.RWMutex
|
||||||
|
|
||||||
vpnIps map[netip.Addr]*HandshakeHostInfo
|
vpnIps map[netip.Addr]*HandshakeHostInfo
|
||||||
@@ -260,6 +259,14 @@ func (hm *HandshakeManager) handleOutbound(vpnIp netip.Addr, lighthouseTriggered
|
|||||||
"style": header.SubTypeName(header.Handshake, hh.machine.Subtype()),
|
"style": header.SubTypeName(header.Handshake, hh.machine.Subtype()),
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Get a remotes object if we don't already have one.
|
||||||
|
// This is mainly to protect us as this should never be the case
|
||||||
|
// NB ^ This comment doesn't jive. It's how the thing gets initialized.
|
||||||
|
// It's the common path. Should it update every time, in case a future LH query/queries give us more info?
|
||||||
|
if hostinfo.remotes == nil {
|
||||||
|
hostinfo.remotes = hm.lightHouse.QueryCache([]netip.Addr{vpnIp})
|
||||||
|
}
|
||||||
|
|
||||||
remotes := hostinfo.remotes.CopyAddrs(hm.mainHostMap.GetPreferredRanges())
|
remotes := hostinfo.remotes.CopyAddrs(hm.mainHostMap.GetPreferredRanges())
|
||||||
remotesHaveChanged := !slices.Equal(remotes, hh.lastRemotes)
|
remotesHaveChanged := !slices.Equal(remotes, hh.lastRemotes)
|
||||||
|
|
||||||
@@ -364,9 +371,6 @@ func (hm *HandshakeManager) StartHandshake(vpnAddr netip.Addr, cacheCb func(*Han
|
|||||||
hostinfo := &HostInfo{
|
hostinfo := &HostInfo{
|
||||||
vpnAddrs: []netip.Addr{vpnAddr},
|
vpnAddrs: []netip.Addr{vpnAddr},
|
||||||
HandshakePacket: make(map[uint8][]byte, 0),
|
HandshakePacket: make(map[uint8][]byte, 0),
|
||||||
// Attached here so a pending hostinfo never exists without one: SetRemote dereferences
|
|
||||||
// it, and create-tunnel -address can reach SetRemote before the handshake loop runs.
|
|
||||||
remotes: hm.lightHouse.QueryCache([]netip.Addr{vpnAddr}),
|
|
||||||
relayState: RelayState{
|
relayState: RelayState{
|
||||||
relays: nil,
|
relays: nil,
|
||||||
relayForByAddr: map[netip.Addr]*Relay{},
|
relayForByAddr: map[netip.Addr]*Relay{},
|
||||||
@@ -942,14 +946,13 @@ func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostIn
|
|||||||
|
|
||||||
hm.DeleteHostInfo(hostinfo)
|
hm.DeleteHostInfo(hostinfo)
|
||||||
hm.StartHandshake(hostinfo.vpnAddrs[0], func(newHH *HandshakeHostInfo) {
|
hm.StartHandshake(hostinfo.vpnAddrs[0], func(newHH *HandshakeHostInfo) {
|
||||||
|
newHH.hostinfo.remotes = hostinfo.remotes
|
||||||
newHH.hostinfo.remotes.BlockRemote(via)
|
newHH.hostinfo.remotes.BlockRemote(via)
|
||||||
newHH.packetStore = hh.packetStore
|
newHH.packetStore = hh.packetStore
|
||||||
hh.packetStore = []*cachedPacket{}
|
hh.packetStore = []*cachedPacket{}
|
||||||
})
|
|
||||||
// sendCloseTunnel may take the hostmap lock, so it must not run under the handshake
|
|
||||||
// manager lock that StartHandshake holds around the callback.
|
|
||||||
hostinfo.vpnAddrs = vpnAddrs
|
hostinfo.vpnAddrs = vpnAddrs
|
||||||
f.sendCloseTunnel(hostinfo)
|
f.sendCloseTunnel(hostinfo)
|
||||||
|
})
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -984,9 +987,6 @@ func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostIn
|
|||||||
nb := make([]byte, 12, 12)
|
nb := make([]byte, 12, 12)
|
||||||
out := make([]byte, mtu)
|
out := make([]byte, mtu)
|
||||||
for _, cp := range hh.packetStore {
|
for _, cp := range hh.packetStore {
|
||||||
// TODO: use a SendBatch here. Each callback lands in
|
|
||||||
// sendNoMetrics -> WriteTo: one syscall per cached packet,
|
|
||||||
// where one sendmmsg could flush the whole store.
|
|
||||||
cp.callback(cp.messageType, cp.messageSubType, hostinfo, cp.packet, nb, out)
|
cp.callback(cp.messageType, cp.messageSubType, hostinfo, cp.packet, nb, out)
|
||||||
}
|
}
|
||||||
f.cachedPacketMetrics.sent.Inc(int64(len(hh.packetStore)))
|
f.cachedPacketMetrics.sent.Inc(int64(len(hh.packetStore)))
|
||||||
@@ -1098,7 +1098,7 @@ func (hm *HandshakeManager) sendHandshakeResponse(via ViaSender, msg []byte, hos
|
|||||||
// We received a valid handshake on this relay, so make sure the relay
|
// We received a valid handshake on this relay, so make sure the relay
|
||||||
// state reflects that, in case it had been marked Disestablished.
|
// state reflects that, in case it had been marked Disestablished.
|
||||||
via.relayHI.relayState.UpdateRelayForByIdxState(via.relay.LocalIndex, Established)
|
via.relayHI.relayState.UpdateRelayForByIdxState(via.relay.LocalIndex, Established)
|
||||||
f.SendVia(via.relayHI, via.relay, msg, make([]byte, 12), make([]byte, mtu), false, 0)
|
f.SendVia(via.relayHI, via.relay, msg, make([]byte, 12), make([]byte, mtu), false)
|
||||||
f.l.Info("Handshake message sent", append(logFields, "relay", via.relayHI.vpnAddrs[0])...)
|
f.l.Info("Handshake message sent", append(logFields, "relay", via.relayHI.vpnAddrs[0])...)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -11,7 +11,6 @@ import (
|
|||||||
"github.com/slackhq/nebula/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
func Test_NewHandshakeManagerVpnIp(t *testing.T) {
|
func Test_NewHandshakeManagerVpnIp(t *testing.T) {
|
||||||
@@ -43,6 +42,8 @@ func Test_NewHandshakeManagerVpnIp(t *testing.T) {
|
|||||||
i2 := blah.StartHandshake(ip, nil)
|
i2 := blah.StartHandshake(ip, nil)
|
||||||
assert.Same(t, i, i2)
|
assert.Same(t, i, i2)
|
||||||
|
|
||||||
|
i.remotes = NewRemoteList([]netip.Addr{}, nil)
|
||||||
|
|
||||||
// Adding something to pending should not affect the main hostmap
|
// Adding something to pending should not affect the main hostmap
|
||||||
assert.Empty(t, mainHM.Hosts)
|
assert.Empty(t, mainHM.Hosts)
|
||||||
|
|
||||||
@@ -83,7 +84,7 @@ func (mw *mockEncWriter) SendMessageToVpnAddr(_ header.MessageType, _ header.Mes
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
func (mw *mockEncWriter) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool, q int) {
|
func (mw *mockEncWriter) SendVia(_ *HostInfo, _ *Relay, _, _, _ []byte, _ bool) {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -234,70 +235,3 @@ func TestHandleIncomingDispatch(t *testing.T) {
|
|||||||
assert.Empty(t, hm.indexes, "orphan stage-2 must not create state")
|
assert.Empty(t, hm.indexes, "orphan stage-2 must not create state")
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
// Test_PendingHandshakeHasRemotes covers create-tunnel -address: a pending hostinfo must already
|
|
||||||
// carry its RemoteList when StartHandshake runs its callback, so SetRemote there, before the
|
|
||||||
// handshake loop has run, is safe and the address becomes one the handshake is sent to.
|
|
||||||
func Test_PendingHandshakeHasRemotes(t *testing.T) {
|
|
||||||
l := test.NewLogger()
|
|
||||||
mainHM := newHostMap(l)
|
|
||||||
preferredRanges := []netip.Prefix{}
|
|
||||||
mainHM.preferredRanges.Store(&preferredRanges)
|
|
||||||
|
|
||||||
hm := NewHandshakeManager(l, mainHM, newTestLighthouse(), &udp.NoopConn{}, defaultHandshakeConfig)
|
|
||||||
|
|
||||||
vpnIp := netip.MustParseAddr("172.1.1.2")
|
|
||||||
remote := netip.MustParseAddrPort("192.168.1.9:4242")
|
|
||||||
|
|
||||||
hi := hm.StartHandshake(vpnIp, func(hh *HandshakeHostInfo) {
|
|
||||||
require.NotNil(t, hh.hostinfo.remotes, "a pending handshake must never be without its RemoteList")
|
|
||||||
hh.hostinfo.SetRemote(remote)
|
|
||||||
})
|
|
||||||
assert.Contains(t, hi.remotes.CopyAddrs(preferredRanges), remote, "the handshake must be sent to the supplied remote")
|
|
||||||
assert.Equal(t, remote, hi.GetRemote())
|
|
||||||
|
|
||||||
// A RemoteList keeps one learned address per host, so a second remote replaces the
|
|
||||||
// first — the same behaviour change-remote has on an established tunnel.
|
|
||||||
other := netip.MustParseAddrPort("192.168.1.10:4242")
|
|
||||||
hi.SetRemote(other)
|
|
||||||
assert.Equal(t, []netip.AddrPort{other}, hi.remotes.CopyAddrs(preferredRanges))
|
|
||||||
assert.Equal(t, other, hi.GetRemote())
|
|
||||||
}
|
|
||||||
|
|
||||||
// newRemotesRaceFixture builds a handshake manager with an established tunnel to vpnAddr whose
|
|
||||||
// RemoteList is the lighthouse's cached list, the state every teardown-during-handshake race starts from.
|
|
||||||
func newRemotesRaceFixture(t *testing.T, vpnAddr netip.Addr) (*HandshakeManager, *Interface, *HostInfo) {
|
|
||||||
t.Helper()
|
|
||||||
l := test.NewLogger()
|
|
||||||
mainHM := newHostMap(l)
|
|
||||||
preferredRanges := []netip.Prefix{}
|
|
||||||
mainHM.preferredRanges.Store(&preferredRanges)
|
|
||||||
|
|
||||||
lh := newTestLighthouse()
|
|
||||||
hm := NewHandshakeManager(l, mainHM, lh, &udp.NoopConn{}, defaultHandshakeConfig)
|
|
||||||
f := &Interface{hostMap: mainHM, lightHouse: lh, handshakeManager: hm, l: l}
|
|
||||||
hm.f = f
|
|
||||||
|
|
||||||
established := &HostInfo{
|
|
||||||
vpnAddrs: []netip.Addr{vpnAddr},
|
|
||||||
localIndexId: 1,
|
|
||||||
remoteIndexId: 101,
|
|
||||||
remotes: lh.QueryCache([]netip.Addr{vpnAddr}),
|
|
||||||
HandshakePacket: map[uint8][]byte{},
|
|
||||||
}
|
|
||||||
mainHM.Lock()
|
|
||||||
mainHM.unlockedAddHostInfo(established, f)
|
|
||||||
mainHM.Unlock()
|
|
||||||
|
|
||||||
return hm, f, established
|
|
||||||
}
|
|
||||||
|
|
||||||
// With no handshake pending, tearing down the last tunnel still evicts the list.
|
|
||||||
func Test_CloseTunnelEvictsWithoutPendingHandshake(t *testing.T) {
|
|
||||||
vpnAddr := netip.MustParseAddr("172.1.1.2")
|
|
||||||
_, f, established := newRemotesRaceFixture(t, vpnAddr)
|
|
||||||
|
|
||||||
f.closeTunnel(established)
|
|
||||||
assert.NotContains(t, f.hostMap.Hosts, vpnAddr)
|
|
||||||
assert.NotContains(t, f.lightHouse.addrMap, vpnAddr)
|
|
||||||
}
|
|
||||||
+6
-16
@@ -24,11 +24,6 @@ type m = map[string]any
|
|||||||
const (
|
const (
|
||||||
Version uint8 = 1
|
Version uint8 = 1
|
||||||
Len = 16
|
Len = 16
|
||||||
|
|
||||||
// MaxOverhead is the most a payload grows on its way to the underlay.
|
|
||||||
// A relayed packet has two headers and two AEAD tags, one for the inner tunnel and another for the relay tunnel.
|
|
||||||
// Every supported cipher (today) has a 16 byte tag.
|
|
||||||
MaxOverhead = 2 * (Len + 16)
|
|
||||||
)
|
)
|
||||||
|
|
||||||
type MessageType uint8
|
type MessageType uint8
|
||||||
@@ -195,20 +190,15 @@ func SubTypeName(t MessageType, s MessageSubType) string {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func IsValidSubType(t MessageType, s MessageSubType) bool {
|
func IsValidSubType(t MessageType, s MessageSubType) bool {
|
||||||
switch t {
|
if n, ok := subTypeMap[t]; ok {
|
||||||
case Message:
|
if _, ok := (*n)[s]; ok {
|
||||||
return s == MessageNone || s == MessageRelay
|
return true
|
||||||
case Handshake:
|
|
||||||
return s == HandshakeIXPSK0
|
|
||||||
case Test:
|
|
||||||
return s == TestReply || s == TestRequest
|
|
||||||
case Control, CloseTunnel, RecvError, LightHouse:
|
|
||||||
return s == 0
|
|
||||||
default:
|
|
||||||
return false
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
// NewHeader turns bytes into a header
|
// NewHeader turns bytes into a header
|
||||||
func NewHeader(b []byte) (*H, error) {
|
func NewHeader(b []byte) (*H, error) {
|
||||||
h := new(H)
|
h := new(H)
|
||||||
|
|||||||
@@ -102,57 +102,6 @@ func TestTypeMap(t *testing.T) {
|
|||||||
}, subTypeMap)
|
}, subTypeMap)
|
||||||
}
|
}
|
||||||
|
|
||||||
// mapIsValidSubType is the pre-refactor, map-driven definition of a valid
|
|
||||||
// subtype. IsValidSubType was reimplemented as an explicit switch; this keeps
|
|
||||||
// the original behavior around so we can prove the switch is equivalent to it.
|
|
||||||
func mapIsValidSubType(t MessageType, s MessageSubType) bool {
|
|
||||||
if n, ok := subTypeMap[t]; ok {
|
|
||||||
if _, ok := (*n)[s]; ok {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIsValidSubType(t *testing.T) {
|
|
||||||
// Explicit intent table: documents exactly which subtypes are valid so the
|
|
||||||
// test stays meaningful even if both the switch and subTypeMap change.
|
|
||||||
assert.True(t, IsValidSubType(Message, MessageNone))
|
|
||||||
assert.True(t, IsValidSubType(Message, MessageRelay))
|
|
||||||
assert.False(t, IsValidSubType(Message, 2))
|
|
||||||
|
|
||||||
assert.True(t, IsValidSubType(Handshake, HandshakeIXPSK0))
|
|
||||||
// HandshakeXXPSK0 is defined but not a wire-valid subtype.
|
|
||||||
assert.False(t, IsValidSubType(Handshake, HandshakeXXPSK0))
|
|
||||||
|
|
||||||
assert.True(t, IsValidSubType(Test, TestRequest))
|
|
||||||
assert.True(t, IsValidSubType(Test, TestReply))
|
|
||||||
assert.False(t, IsValidSubType(Test, 2))
|
|
||||||
|
|
||||||
// These types only ever carry subtype 0.
|
|
||||||
for _, mt := range []MessageType{Control, CloseTunnel, RecvError, LightHouse} {
|
|
||||||
assert.True(t, IsValidSubType(mt, 0), "type %d subtype 0 should be valid", mt)
|
|
||||||
assert.False(t, IsValidSubType(mt, 1), "type %d subtype 1 should be invalid", mt)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Unknown/unassigned types are never valid.
|
|
||||||
assert.False(t, IsValidSubType(99, 0))
|
|
||||||
|
|
||||||
// Exhaustive proof of equivalence with the original map-driven logic across
|
|
||||||
// the entire (type, subtype) input space.
|
|
||||||
for ti := 0; ti <= 0xff; ti++ {
|
|
||||||
for si := 0; si <= 0xff; si++ {
|
|
||||||
mt, mst := MessageType(ti), MessageSubType(si)
|
|
||||||
assert.Equalf(t, mapIsValidSubType(mt, mst), IsValidSubType(mt, mst),
|
|
||||||
"IsValidSubType(%d, %d) diverged from map-driven definition", ti, si)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// H method must delegate to the package function.
|
|
||||||
assert.True(t, (&H{Type: Test, Subtype: TestReply}).IsValidSubType())
|
|
||||||
assert.False(t, (&H{Type: Handshake, Subtype: HandshakeXXPSK0}).IsValidSubType())
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestHeader_String(t *testing.T) {
|
func TestHeader_String(t *testing.T) {
|
||||||
assert.Equal(
|
assert.Equal(
|
||||||
t,
|
t,
|
||||||
|
|||||||
+69
-76
@@ -6,6 +6,7 @@ import (
|
|||||||
"errors"
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
|
"net"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"slices"
|
"slices"
|
||||||
"sync"
|
"sync"
|
||||||
@@ -17,6 +18,7 @@ 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
|
||||||
@@ -237,15 +239,11 @@ const (
|
|||||||
|
|
||||||
type HostInfo struct {
|
type HostInfo struct {
|
||||||
remote atomic.Pointer[netip.AddrPort]
|
remote atomic.Pointer[netip.AddrPort]
|
||||||
ConnectionState *ConnectionState
|
remotes *RemoteList
|
||||||
|
|
||||||
// Traffic bits, pendingDeletion, and the rebind epoch we last sent under
|
|
||||||
state atomic.Uint32
|
|
||||||
|
|
||||||
promoteCounter atomic.Uint32
|
promoteCounter atomic.Uint32
|
||||||
|
ConnectionState *ConnectionState
|
||||||
remoteIndexId uint32
|
remoteIndexId uint32
|
||||||
localIndexId uint32
|
localIndexId uint32
|
||||||
remotes *RemoteList
|
|
||||||
|
|
||||||
// vpnAddrs is a list of vpn addresses assigned to this host that are within our own vpn networks
|
// vpnAddrs is a list of vpn addresses assigned to this host that are within our own vpn networks
|
||||||
// The host may have other vpn addresses that are outside our
|
// The host may have other vpn addresses that are outside our
|
||||||
@@ -264,6 +262,11 @@ type HostInfo struct {
|
|||||||
// This is used to limit lighthouse re-queries in chatty clients
|
// This is used to limit lighthouse re-queries in chatty clients
|
||||||
nextLHQuery atomic.Int64
|
nextLHQuery atomic.Int64
|
||||||
|
|
||||||
|
// lastRebindCount is the other side of Interface.rebindCount, if these values don't match then we need to ask LH
|
||||||
|
// for a punch from the remote end of this tunnel. The goal being to prime their conntrack for our traffic just like
|
||||||
|
// with a handshake
|
||||||
|
lastRebindCount int8
|
||||||
|
|
||||||
// lastHandshakeTime records the time the remote side told us about at the stage when the handshake was completed locally
|
// lastHandshakeTime records the time the remote side told us about at the stage when the handshake was completed locally
|
||||||
// Stage 1 packet will contain it if I am a responder, stage 2 packet if I am an initiator
|
// Stage 1 packet will contain it if I am a responder, stage 2 packet if I am an initiator
|
||||||
// This is used to avoid an attack where a handshake packet is replayed after some time
|
// This is used to avoid an attack where a handshake packet is replayed after some time
|
||||||
@@ -272,6 +275,9 @@ type HostInfo struct {
|
|||||||
lastRoam time.Time
|
lastRoam time.Time
|
||||||
lastRoamRemote netip.AddrPort
|
lastRoamRemote netip.AddrPort
|
||||||
|
|
||||||
|
//TODO: in, out, and others might benefit from being an atomic.Int32. We could collapse connectionManager pendingDeletion, relayUsed, and in/out into this 1 thing
|
||||||
|
in, out, pendingDeletion atomic.Bool
|
||||||
|
|
||||||
// lastUsed tracks the last time ConnectionManager checked the tunnel and it was in use.
|
// lastUsed tracks the last time ConnectionManager checked the tunnel and it was in use.
|
||||||
// This value will be behind against actual tunnel utilization in the hot path.
|
// This value will be behind against actual tunnel utilization in the hot path.
|
||||||
// This should only be used by the ConnectionManagers ticker routine.
|
// This should only be used by the ConnectionManagers ticker routine.
|
||||||
@@ -537,17 +543,6 @@ func (hm *HostMap) unlockedDeleteHostInfo(hostinfo *HostInfo) bool {
|
|||||||
return final
|
return final
|
||||||
}
|
}
|
||||||
|
|
||||||
func (hm *HostMap) QueryIndexCached(index uint32, cache map[uint32]*HostInfo) *HostInfo {
|
|
||||||
if out, ok := cache[index]; ok {
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
out := hm.QueryIndex(index)
|
|
||||||
if out != nil {
|
|
||||||
cache[index] = out
|
|
||||||
}
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
|
|
||||||
func (hm *HostMap) QueryIndex(index uint32) *HostInfo {
|
func (hm *HostMap) QueryIndex(index uint32) *HostInfo {
|
||||||
hm.RLock()
|
hm.RLock()
|
||||||
if h, ok := hm.Indexes[index]; ok {
|
if h, ok := hm.Indexes[index]; ok {
|
||||||
@@ -663,7 +658,7 @@ func (hm *HostMap) unlockedAddHostInfo(hostinfo *HostInfo, f *Interface) {
|
|||||||
hm.Indexes[hostinfo.localIndexId] = hostinfo
|
hm.Indexes[hostinfo.localIndexId] = hostinfo
|
||||||
hm.RemoteIndexes[hostinfo.remoteIndexId] = hostinfo
|
hm.RemoteIndexes[hostinfo.remoteIndexId] = hostinfo
|
||||||
|
|
||||||
hostinfo.markOut(f.rebindEpoch.Load())
|
hostinfo.out.Store(true)
|
||||||
if f.connectionManager != nil { // f.connectionManager is only nil in some unit tests
|
if f.connectionManager != nil { // f.connectionManager is only nil in some unit tests
|
||||||
f.connectionManager.trafficTimer.Add(hostinfo.localIndexId, f.connectionManager.checkInterval)
|
f.connectionManager.trafficTimer.Add(hostinfo.localIndexId, f.connectionManager.checkInterval)
|
||||||
}
|
}
|
||||||
@@ -764,64 +759,6 @@ func (i *HostInfo) TryPromoteBest(preferredRanges []netip.Prefix, ifce *Interfac
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Bits within HostInfo.state, everything above stateEpochShift is the epoch
|
|
||||||
const (
|
|
||||||
stateIn uint32 = 1 << iota
|
|
||||||
stateOut
|
|
||||||
statePendingDeletion
|
|
||||||
|
|
||||||
stateFlags = stateIn | stateOut | statePendingDeletion
|
|
||||||
// The epoch is the top 29 bits, it would take 2^29 rebinds to wrap and we will never get there
|
|
||||||
stateEpochShift = 3
|
|
||||||
)
|
|
||||||
|
|
||||||
// markIn records inbound traffic
|
|
||||||
func (i *HostInfo) markIn() {
|
|
||||||
if i.state.Load()&stateIn == 0 {
|
|
||||||
i.state.Or(stateIn)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// markOut records a send and reports whether the epoch moved, meaning we want a punch from the far side
|
|
||||||
func (i *HostInfo) markOut(epoch uint32) bool {
|
|
||||||
e := epoch << stateEpochShift
|
|
||||||
for {
|
|
||||||
old := i.state.Load()
|
|
||||||
if old&stateOut != 0 && old&^stateFlags == e {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
if i.state.CompareAndSwap(old, old&stateFlags|stateOut|e) {
|
|
||||||
return old&^stateFlags != e
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// markOutOnly records a send without consuming the rebind epoch, for paths that cannot act on a requery
|
|
||||||
func (i *HostInfo) markOutOnly() {
|
|
||||||
if i.state.Load()&stateOut == 0 {
|
|
||||||
i.state.Or(stateOut)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// takeTraffic clears both traffic bits, leaving the epoch alone, and reports what they were
|
|
||||||
func (i *HostInfo) takeTraffic() (in bool, out bool) {
|
|
||||||
old := i.state.And(^(stateIn | stateOut))
|
|
||||||
return old&stateIn != 0, old&stateOut != 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *HostInfo) setPendingDeletion(v bool) {
|
|
||||||
if v {
|
|
||||||
i.state.Or(statePendingDeletion)
|
|
||||||
} else {
|
|
||||||
i.state.And(^statePendingDeletion)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *HostInfo) isPendingDeletion() bool {
|
|
||||||
return i.state.Load()&statePendingDeletion != 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func (i *HostInfo) GetCert() *cert.CachedCertificate {
|
func (i *HostInfo) GetCert() *cert.CachedCertificate {
|
||||||
if i.ConnectionState != nil {
|
if i.ConnectionState != nil {
|
||||||
return i.ConnectionState.peerCert
|
return i.ConnectionState.peerCert
|
||||||
@@ -928,3 +865,59 @@ 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
|
||||||
|
}
|
||||||
@@ -401,49 +401,3 @@ func TestHostMap_RelayState(t *testing.T) {
|
|||||||
assert.Equal(t, []netip.Addr{}, h1.relayState.relays)
|
assert.Equal(t, []netip.Addr{}, h1.relayState.relays)
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// sentSinceCheck reports whether anything has been sent since the connection manager last looked. Test only:
|
|
||||||
// production reads the out bit through takeTraffic on the connection manager tick.
|
|
||||||
func (i *HostInfo) sentSinceCheck() bool {
|
|
||||||
return i.state.Load()&stateOut != 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestHostInfo_markOut(t *testing.T) {
|
|
||||||
h := &HostInfo{}
|
|
||||||
h.markOut(5) // stamped when the tunnel was added
|
|
||||||
|
|
||||||
// A tunnel already on the current epoch has nothing to report, which is what keeps a fresh tunnel from
|
|
||||||
// requerying on its first packet
|
|
||||||
assert.False(t, h.markOut(5), "an unchanged epoch should not report a move")
|
|
||||||
assert.True(t, h.sentSinceCheck(), "the send is still recorded as traffic")
|
|
||||||
|
|
||||||
// A rebind is observed exactly once, so we requery once per rebind
|
|
||||||
assert.True(t, h.markOut(6), "a bumped epoch should report a move")
|
|
||||||
assert.False(t, h.markOut(6), "the epoch move should only be reported once")
|
|
||||||
|
|
||||||
// Traffic and pendingDeletion live in the same word and must survive an epoch change
|
|
||||||
h.setPendingDeletion(true)
|
|
||||||
h.markIn()
|
|
||||||
assert.True(t, h.markOut(7))
|
|
||||||
assert.True(t, h.isPendingDeletion(), "pendingDeletion must survive an epoch change")
|
|
||||||
in, out := h.takeTraffic()
|
|
||||||
assert.True(t, in, "inbound traffic must survive an epoch change")
|
|
||||||
assert.True(t, out)
|
|
||||||
|
|
||||||
// Clearing the traffic bits leaves the epoch alone, otherwise an idle tunnel would requery forever
|
|
||||||
assert.False(t, h.markOut(7), "takeTraffic must not disturb the epoch")
|
|
||||||
}
|
|
||||||
|
|
||||||
// A relayed send records traffic but must leave the rebind epoch for the direct path to consume, otherwise
|
|
||||||
// relaying to a host swallows the requery that gets the far side punching at our new address.
|
|
||||||
func TestHostInfo_markOutOnly(t *testing.T) {
|
|
||||||
h := &HostInfo{}
|
|
||||||
h.markOut(5)
|
|
||||||
|
|
||||||
h.markOutOnly()
|
|
||||||
assert.True(t, h.sentSinceCheck(), "a relayed send is still outbound traffic")
|
|
||||||
assert.False(t, h.markOut(5), "a relayed send must not disturb the epoch")
|
|
||||||
|
|
||||||
assert.True(t, h.markOut(6), "a relayed send must not consume the epoch edge")
|
|
||||||
assert.False(t, h.markOut(6))
|
|
||||||
}
|
|
||||||
@@ -2,34 +2,17 @@ package nebula
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"context"
|
"context"
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"log/slog"
|
"log/slog"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/firewall"
|
"github.com/slackhq/nebula/firewall"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/iputil"
|
"github.com/slackhq/nebula/iputil"
|
||||||
"github.com/slackhq/nebula/logging"
|
|
||||||
"github.com/slackhq/nebula/noiseutil"
|
"github.com/slackhq/nebula/noiseutil"
|
||||||
"github.com/slackhq/nebula/overlay/batch"
|
|
||||||
"github.com/slackhq/nebula/overlay/tio"
|
|
||||||
"github.com/slackhq/nebula/routing"
|
"github.com/slackhq/nebula/routing"
|
||||||
)
|
)
|
||||||
|
|
||||||
func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.ParsedPacket, nb []byte, sendBatch *batch.SendBatch, rejectBuf []byte, q int, localCache firewall.ConntrackCache) {
|
func (f *Interface) consumeInsidePacket(packet []byte, fwPacket *firewall.Packet, nb, out []byte, q int, localCache firewall.ConntrackCache) {
|
||||||
// borrowed: pkt.Bytes is owned by the originating tio.Queue and is
|
|
||||||
// only valid until the next Read on that queue. Every consumer below
|
|
||||||
// (parse, self-forward, handshake cache, sendInsideMessage) reads it
|
|
||||||
// synchronously; do not retain pkt outside this call. If a future
|
|
||||||
// caller needs to keep the packet, use pkt.Clone() to detach it from
|
|
||||||
// the borrow.
|
|
||||||
//
|
|
||||||
// pkt.Bytes is either one IP datagram (GSO zero) or a TSO/USO
|
|
||||||
// superpacket. In both cases the L3+L4 headers at the start describe
|
|
||||||
// the same 5-tuple every segment will share, so a single newPacket /
|
|
||||||
// firewall check covers the whole superpacket.
|
|
||||||
packet := pkt.Bytes
|
|
||||||
err := newPacket(packet, false, fwPacket)
|
err := newPacket(packet, false, fwPacket)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
@@ -54,17 +37,7 @@ func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.Parse
|
|||||||
// 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 {
|
||||||
// Write copies into the kernel queue synchronously, so seg's lifetime ends at return.
|
_, err := f.readers[q].Write(packet)
|
||||||
// A self-forwarded superpacket would be re-handed to the
|
|
||||||
// kernel as one giant blob; segment first so the loopback
|
|
||||||
// path sees one IP datagram per Write.
|
|
||||||
err := tio.SegmentSuperpacket(pkt, func(seg []byte) error {
|
|
||||||
// The kernel may have left the transport checksum for hardware
|
|
||||||
// offload to finish; nothing between here and the tun will.
|
|
||||||
iputil.SetTransportChecksum(seg)
|
|
||||||
_, werr := f.queues[q].Write(seg)
|
|
||||||
return werr
|
|
||||||
})
|
|
||||||
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)
|
||||||
}
|
}
|
||||||
@@ -79,24 +52,12 @@ func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.Parse
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
hostinfo, ready := f.getOrHandshakeConsiderRouting(&fwPacket.Packet, func(hh *HandshakeHostInfo) {
|
hostinfo, ready := f.getOrHandshakeConsiderRouting(fwPacket, func(hh *HandshakeHostInfo) {
|
||||||
// borrowed: SegmentSuperpacket builds each segment in the kernel-supplied pkt
|
hh.cachePacket(f.l, header.Message, 0, packet, f.sendMessageNow, f.cachedPacketMetrics)
|
||||||
// bytes underneath. cachePacket explicitly copies its argument (handshake_manager.go cachePacket),
|
|
||||||
// so retaining segments past the loop is safe.
|
|
||||||
err := tio.SegmentSuperpacket(pkt, func(seg []byte) error {
|
|
||||||
hh.cachePacket(f.l, header.Message, 0, seg, f.sendMessageNow, f.cachedPacketMetrics)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if err != nil && f.l.Enabled(context.Background(), slog.LevelDebug) {
|
|
||||||
f.l.Debug("Failed to segment superpacket for handshake cache",
|
|
||||||
"error", err,
|
|
||||||
"vpnAddr", fwPacket.RemoteAddr,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
})
|
})
|
||||||
|
|
||||||
if hostinfo == nil {
|
if hostinfo == nil {
|
||||||
f.rejectInside(packet, rejectBuf, q)
|
f.rejectInside(packet, out, q)
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
f.l.Debug("dropping outbound packet, vpnAddr not in our vpn networks or in unsafe networks",
|
f.l.Debug("dropping outbound packet, vpnAddr not in our vpn networks or in unsafe networks",
|
||||||
"vpnAddr", fwPacket.RemoteAddr,
|
"vpnAddr", fwPacket.RemoteAddr,
|
||||||
@@ -110,11 +71,12 @@ func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.Parse
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
dropReason := f.firewall.Drop(fwPacket.Packet, false, hostinfo, f.pki.GetCAPool(), localCache)
|
dropReason := f.firewall.Drop(*fwPacket, false, hostinfo, f.pki.GetCAPool(), localCache)
|
||||||
if dropReason == nil {
|
if dropReason == nil {
|
||||||
f.sendInsideMessage(hostinfo, pkt, nb, sendBatch)
|
f.sendNoMetrics(header.Message, 0, hostinfo.ConnectionState, hostinfo, netip.AddrPort{}, packet, nb, out, q)
|
||||||
|
|
||||||
} else {
|
} else {
|
||||||
f.rejectInside(packet, rejectBuf, q)
|
f.rejectInside(packet, out, q)
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
hostinfo.logger(f.l).Debug("dropping outbound packet",
|
hostinfo.logger(f.l).Debug("dropping outbound packet",
|
||||||
"fwPacket", fwPacket,
|
"fwPacket", fwPacket,
|
||||||
@@ -124,122 +86,6 @@ func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.Parse
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) sendInsideEncrypt(hostinfo *HostInfo, ci *ConnectionState, seg, scratch, nb []byte) []byte {
|
|
||||||
if noiseutil.EncryptLockNeeded {
|
|
||||||
ci.writeLock.Lock()
|
|
||||||
}
|
|
||||||
c := ci.messageCounter.Add(1)
|
|
||||||
|
|
||||||
out := header.Encode(scratch, header.Version, header.Message, 0, hostinfo.remoteIndexId, c)
|
|
||||||
|
|
||||||
out, encErr := ci.eKey.EncryptDanger(out, out, seg, c, nb)
|
|
||||||
if noiseutil.EncryptLockNeeded {
|
|
||||||
ci.writeLock.Unlock()
|
|
||||||
}
|
|
||||||
if encErr != nil {
|
|
||||||
hostinfo.logger(f.l).Error("Failed to encrypt outgoing packet",
|
|
||||||
"error", encErr,
|
|
||||||
"udpAddr", hostinfo.GetRemote(),
|
|
||||||
"counter", c,
|
|
||||||
)
|
|
||||||
// Skip this segment; the rest of the superpacket can still go out. TCP will retransmit anything we drop here.
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
|
|
||||||
// sendInsideMessage encrypts a firewall-approved inside packet (or every
|
|
||||||
// segment of a TSO/USO superpacket) into the caller's batch slot for
|
|
||||||
// later sendmmsg flush. Segmentation is fused with encryption here so the
|
|
||||||
// kernel-supplied superpacket bytes never get written into a separate
|
|
||||||
// scratch arena: SegmentSuperpacket builds each segment's plaintext in
|
|
||||||
// segScratch[:segLen] in turn, and we encrypt directly into a fresh SendBatch slot.
|
|
||||||
func (f *Interface) sendInsideMessage(hostinfo *HostInfo, pkt tio.Packet, nb []byte, sendBatch *batch.SendBatch) {
|
|
||||||
ci := hostinfo.ConnectionState
|
|
||||||
if ci.eKey == nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// One traffic-out mark covers every segment of the superpacket; doing it
|
|
||||||
// per segment in sendInsideEncrypt paid an atomic store up to ~45 extra
|
|
||||||
// times per TSO packet, inside writeLock under boring crypto.
|
|
||||||
//
|
|
||||||
// We rebound since this tunnel last sent, ask the lighthouse to get the far side punching at us again
|
|
||||||
if f.connectionManager.Out(hostinfo) {
|
|
||||||
f.lightHouse.QueryServer(hostinfo.vpnAddrs[0])
|
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
|
||||||
hostinfo.logger(f.l).Debug("Lighthouse update triggered for punch due to rebind epoch",
|
|
||||||
"vpnAddrs", hostinfo.vpnAddrs,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
remote := hostinfo.GetRemote()
|
|
||||||
if !remote.IsValid() { //the relay path
|
|
||||||
//first, find our relay hostinfo:
|
|
||||||
var relayHostInfo *HostInfo
|
|
||||||
var relay *Relay
|
|
||||||
var err error
|
|
||||||
for _, relayIP := range hostinfo.relayState.CopyRelayIps() {
|
|
||||||
relayHostInfo, relay, err = f.hostMap.QueryVpnAddrsRelayFor(hostinfo.vpnAddrs, relayIP)
|
|
||||||
if err != nil {
|
|
||||||
hostinfo.relayState.DeleteRelay(relayIP)
|
|
||||||
hostinfo.logger(f.l).Info("sendNoMetrics failed to find HostInfo",
|
|
||||||
"relay", relayIP,
|
|
||||||
"error", err,
|
|
||||||
)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if relayHostInfo == nil || relay == nil {
|
|
||||||
//failure already logged
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
err = tio.SegmentSuperpacket(pkt, func(seg []byte) error {
|
|
||||||
//relay header + header + plaintext + AEAD tag + relay tag
|
|
||||||
scratch := sendBatch.Reserve(len(seg) + header.MaxOverhead)
|
|
||||||
|
|
||||||
innerPacket := f.sendInsideEncrypt(hostinfo, ci, seg, scratch[header.Len:], nb)
|
|
||||||
if innerPacket == nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
//now we need to do a relay-encrypt:
|
|
||||||
toSend, err := f.prepareSendVia(relayHostInfo, relay, innerPacket, nb, scratch, true)
|
|
||||||
if err != nil {
|
|
||||||
//already logged
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
sendBatch.Commit(toSend, relayHostInfo.GetRemote())
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if err != nil {
|
|
||||||
hostinfo.logger(f.l).Error("Failed to segment superpacket for relay send", "error", err)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
err := tio.SegmentSuperpacket(pkt, func(seg []byte) error {
|
|
||||||
// header + plaintext + AEAD tag (16 bytes for both AES-GCM and ChaCha20-Poly1305)
|
|
||||||
scratch := sendBatch.Reserve(header.Len + len(seg) + 16)
|
|
||||||
|
|
||||||
out := f.sendInsideEncrypt(hostinfo, ci, seg, scratch, nb)
|
|
||||||
if out == nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
sendBatch.Commit(out, remote)
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if err != nil {
|
|
||||||
hostinfo.logger(f.l).Error("Failed to segment superpacket for send", "error", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *Interface) rejectInside(packet []byte, out []byte, q int) {
|
func (f *Interface) rejectInside(packet []byte, out []byte, q int) {
|
||||||
if !f.firewall.OutboundSendReject {
|
if !f.firewall.OutboundSendReject {
|
||||||
return
|
return
|
||||||
@@ -250,36 +96,33 @@ func (f *Interface) rejectInside(packet []byte, out []byte, q int) {
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
_, err := f.queues[q].Write(out)
|
_, err := f.readers[q].Write(out)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
f.l.Error("Failed to write to tun", "error", err)
|
f.l.Error("Failed to write to tun", "error", err)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) rejectOutside(packet []byte, ci *ConnectionState, hostinfo *HostInfo, nb, rejectBuf []byte, q int) {
|
func (f *Interface) rejectOutside(packet []byte, ci *ConnectionState, hostinfo *HostInfo, nb, out []byte, q int) {
|
||||||
if !f.firewall.InboundSendReject {
|
if !f.firewall.InboundSendReject {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
// split rejectBuf to make sure we have room to write the plaintext rejection, then encrypt it, without trampling anything
|
out = iputil.CreateRejectPacket(packet, out)
|
||||||
// we can't re-use packet, if we need to send an icmp reject, it won't be long enough.
|
|
||||||
half := len(rejectBuf) / 2
|
|
||||||
encryptBuf := rejectBuf[0:0:half] //the first half of rejectBuf's capacity, len set to 0
|
|
||||||
buildBuf := rejectBuf[half:]
|
|
||||||
|
|
||||||
out := iputil.CreateRejectPacket(packet, buildBuf)
|
|
||||||
if len(out) == 0 {
|
if len(out) == 0 {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
if len(out) > iputil.MaxRejectPacketSize {
|
if len(out) > iputil.MaxRejectPacketSize {
|
||||||
if f.l.Enabled(context.Background(), slog.LevelInfo) {
|
if f.l.Enabled(context.Background(), slog.LevelInfo) {
|
||||||
f.l.Info("rejectOutside: packet too big, not sending", "packet", packet, "outPacket", out)
|
f.l.Info("rejectOutside: packet too big, not sending",
|
||||||
|
"packet", packet,
|
||||||
|
"outPacket", out,
|
||||||
|
)
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
f.sendNoMetrics(header.Message, 0, ci, hostinfo, netip.AddrPort{}, out, nb, encryptBuf, q)
|
f.sendNoMetrics(header.Message, 0, ci, hostinfo, netip.AddrPort{}, out, nb, packet, q)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Handshake will attempt to initiate a tunnel with the provided vpn address. This is a no-op if the tunnel is already established or being established
|
// Handshake will attempt to initiate a tunnel with the provided vpn address. This is a no-op if the tunnel is already established or being established
|
||||||
@@ -373,7 +216,7 @@ func (f *Interface) getOrHandshakeConsiderRouting(fwPacket *firewall.Packet, cac
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) sendMessageNow(t header.MessageType, st header.MessageSubType, hostinfo *HostInfo, p, nb, out []byte) {
|
func (f *Interface) sendMessageNow(t header.MessageType, st header.MessageSubType, hostinfo *HostInfo, p, nb, out []byte) {
|
||||||
fp := &firewall.ParsedPacket{}
|
fp := &firewall.Packet{}
|
||||||
err := newPacket(p, false, fp)
|
err := newPacket(p, false, fp)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
f.l.Warn("error while parsing outgoing packet for firewall check", "error", err)
|
f.l.Warn("error while parsing outgoing packet for firewall check", "error", err)
|
||||||
@@ -381,7 +224,7 @@ func (f *Interface) sendMessageNow(t header.MessageType, st header.MessageSubTyp
|
|||||||
}
|
}
|
||||||
|
|
||||||
// check if packet is in outbound fw rules
|
// check if packet is in outbound fw rules
|
||||||
dropReason := f.firewall.Drop(fp.Packet, false, hostinfo, f.pki.GetCAPool(), nil)
|
dropReason := f.firewall.Drop(*fp, false, hostinfo, f.pki.GetCAPool(), nil)
|
||||||
if dropReason != nil {
|
if dropReason != nil {
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
f.l.Debug("dropping cached packet",
|
f.l.Debug("dropping cached packet",
|
||||||
@@ -440,13 +283,21 @@ func (f *Interface) dropExhausted(hostinfo *HostInfo, c uint64, msg string) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) prepareSendVia(via *HostInfo,
|
// SendVia sends a payload through a Relay tunnel. No authentication or encryption is done
|
||||||
|
// to the payload for the ultimate target host, making this a useful method for sending
|
||||||
|
// handshake messages to peers through relay tunnels.
|
||||||
|
// via is the HostInfo through which the message is relayed.
|
||||||
|
// ad is the plaintext data to authenticate, but not encrypt
|
||||||
|
// nb is a buffer used to store the nonce value, re-used for performance reasons.
|
||||||
|
// out is a buffer used to store the result of the Encrypt operation
|
||||||
|
// q indicates which writer to use to send the packet.
|
||||||
|
func (f *Interface) SendVia(via *HostInfo,
|
||||||
relay *Relay,
|
relay *Relay,
|
||||||
ad,
|
ad,
|
||||||
nb,
|
nb,
|
||||||
out []byte,
|
out []byte,
|
||||||
nocopy bool,
|
nocopy bool,
|
||||||
) ([]byte, error) {
|
) {
|
||||||
if noiseutil.EncryptLockNeeded {
|
if noiseutil.EncryptLockNeeded {
|
||||||
// NOTE: for goboring AESGCMTLS we need to lock because of the nonce check
|
// NOTE: for goboring AESGCMTLS we need to lock because of the nonce check
|
||||||
via.ConnectionState.writeLock.Lock()
|
via.ConnectionState.writeLock.Lock()
|
||||||
@@ -457,11 +308,11 @@ func (f *Interface) prepareSendVia(via *HostInfo,
|
|||||||
via.ConnectionState.writeLock.Unlock()
|
via.ConnectionState.writeLock.Unlock()
|
||||||
}
|
}
|
||||||
f.dropExhausted(via, c, "Dropping outbound relay packets, tunnel message counter is exhausted")
|
f.dropExhausted(via, c, "Dropping outbound relay packets, tunnel message counter is exhausted")
|
||||||
return nil, fmt.Errorf("tunnel message counter is exhausted")
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
out = header.Encode(out, header.Version, header.Message, header.MessageRelay, relay.RemoteIndex, c)
|
out = header.Encode(out, header.Version, header.Message, header.MessageRelay, relay.RemoteIndex, c)
|
||||||
f.connectionManager.OutNoRebind(via)
|
f.connectionManager.Out(via)
|
||||||
|
|
||||||
// Authenticate the header and payload, but do not encrypt for this message type.
|
// Authenticate the header and payload, but do not encrypt for this message type.
|
||||||
// The payload consists of the inner, unencrypted Nebula header, as well as the end-to-end encrypted payload.
|
// The payload consists of the inner, unencrypted Nebula header, as well as the end-to-end encrypted payload.
|
||||||
@@ -475,7 +326,7 @@ func (f *Interface) prepareSendVia(via *HostInfo,
|
|||||||
"headerLen", len(out),
|
"headerLen", len(out),
|
||||||
"cipherOverhead", via.ConnectionState.eKey.Overhead(),
|
"cipherOverhead", via.ConnectionState.eKey.Overhead(),
|
||||||
)
|
)
|
||||||
return nil, io.ErrShortBuffer
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
// The header bytes are written to the 'out' slice; Grow the slice to hold the header and associated data payload.
|
// The header bytes are written to the 'out' slice; Grow the slice to hold the header and associated data payload.
|
||||||
@@ -495,33 +346,13 @@ func (f *Interface) prepareSendVia(via *HostInfo,
|
|||||||
}
|
}
|
||||||
if err != nil {
|
if err != nil {
|
||||||
via.logger(f.l).Info("Failed to EncryptDanger in sendVia", "error", err)
|
via.logger(f.l).Info("Failed to EncryptDanger in sendVia", "error", err)
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
f.connectionManager.RelayUsed(relay.LocalIndex)
|
|
||||||
return out, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// SendVia sends a payload through a Relay tunnel. No authentication or encryption is done
|
|
||||||
// to the payload for the ultimate target host, making this a useful method for sending
|
|
||||||
// handshake messages to peers through relay tunnels.
|
|
||||||
// via is the HostInfo through which the message is relayed.
|
|
||||||
// ad is the plaintext data to authenticate, but not encrypt
|
|
||||||
// nb is a buffer used to store the nonce value, re-used for performance reasons.
|
|
||||||
// out is a buffer used to store the result of the Encrypt operation
|
|
||||||
// q indicates which writer to use to send the packet.
|
|
||||||
func (f *Interface) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool, q int) {
|
|
||||||
toSend, err := f.prepareSendVia(via, relay, ad, nb, out, nocopy)
|
|
||||||
if err != nil {
|
|
||||||
// already logged by prepareSendVia
|
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
err = f.writers[0].WriteTo(out, via.GetRemote())
|
||||||
err = f.writers[q].WriteTo(toSend, via.GetRemote())
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
if l, ok := logging.RateLimited(f.l, f.udpRelayTxErrLimiter); ok {
|
via.logger(f.l).Info("Failed to WriteTo in sendVia", "error", err)
|
||||||
via.logger(l).Info("Failed to WriteTo in sendVia", "error", err)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
f.connectionManager.RelayUsed(relay.LocalIndex)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType, ci *ConnectionState, hostinfo *HostInfo, remote netip.AddrPort, p, nb, out []byte, q int) {
|
func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType, ci *ConnectionState, hostinfo *HostInfo, remote netip.AddrPort, p, nb, out []byte, q int) {
|
||||||
@@ -529,26 +360,16 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
useRelay := !remote.IsValid() && !hostinfo.GetRemote().IsValid()
|
useRelay := !remote.IsValid() && !hostinfo.GetRemote().IsValid()
|
||||||
|
|
||||||
// The encrypt appends to out in place and a relayed packet is then wrapped in place,
|
|
||||||
// so out has to fit the whole packet up front or the encrypt reallocates out from under SendVia.
|
|
||||||
// We cap the MTU of tun devices and routes we create ourselves, so only a host that set a bigger MTU than we allow gets here.
|
|
||||||
need := header.Len + len(p) + ci.eKey.Overhead()
|
|
||||||
if useRelay {
|
|
||||||
// The relay tunnel runs the same cipher, and adds its own header and tag
|
|
||||||
need += header.Len + ci.eKey.Overhead()
|
|
||||||
}
|
|
||||||
if cap(out) < need {
|
|
||||||
if l, ok := logging.RateLimited(f.l, f.txOversizeLimiter); ok {
|
|
||||||
hostinfo.logger(l).Error("Dropping outbound packet, out buffer not large enough", "outCap", cap(out), "payloadLen", len(p), "relayed", useRelay)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fullOut := out
|
fullOut := out
|
||||||
|
|
||||||
if useRelay {
|
if useRelay {
|
||||||
|
if len(out) < header.Len {
|
||||||
|
// out always has a capacity of mtu, but not always a length greater than the header.Len.
|
||||||
|
// Grow it to make sure the next operation works.
|
||||||
|
out = out[:header.Len]
|
||||||
|
}
|
||||||
// Save a header's worth of data at the front of the 'out' buffer.
|
// Save a header's worth of data at the front of the 'out' buffer.
|
||||||
out = out[header.Len:header.Len]
|
out = out[header.Len:]
|
||||||
}
|
}
|
||||||
|
|
||||||
if noiseutil.EncryptLockNeeded {
|
if noiseutil.EncryptLockNeeded {
|
||||||
@@ -566,13 +387,17 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
|
|||||||
|
|
||||||
//l.WithField("trace", string(debug.Stack())).Error("out Header ", &Header{Version, t, st, 0, hostinfo.remoteIndexId, c}, p)
|
//l.WithField("trace", string(debug.Stack())).Error("out Header ", &Header{Version, t, st, 0, hostinfo.remoteIndexId, c}, p)
|
||||||
out = header.Encode(out, header.Version, t, st, hostinfo.remoteIndexId, c)
|
out = header.Encode(out, header.Version, t, st, hostinfo.remoteIndexId, c)
|
||||||
// A closing tunnel is torn down right after this, so skip the connection manager entirely: no point recording
|
f.connectionManager.Out(hostinfo)
|
||||||
// traffic or asking the lighthouse for a punch. Otherwise, if we rebound since this tunnel last sent, ask the
|
|
||||||
// lighthouse to get the far side punching at us again.
|
// Query our LH if we haven't since the last time we've been rebound, this will cause the remote to punch against
|
||||||
if t != header.CloseTunnel && f.connectionManager.Out(hostinfo) {
|
// all our addrs and enable a faster roaming.
|
||||||
|
if t != header.CloseTunnel && hostinfo.lastRebindCount != f.rebindCount {
|
||||||
|
//NOTE: there is an update hole if a tunnel isn't used and exactly 256 rebinds occur before the tunnel is
|
||||||
|
// finally used again. This tunnel would eventually be torn down and recreated if this action didn't help.
|
||||||
f.lightHouse.QueryServer(hostinfo.vpnAddrs[0])
|
f.lightHouse.QueryServer(hostinfo.vpnAddrs[0])
|
||||||
|
hostinfo.lastRebindCount = f.rebindCount
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
f.l.Debug("Lighthouse update triggered for punch due to rebind epoch",
|
f.l.Debug("Lighthouse update triggered for punch due to rebind counter",
|
||||||
"vpnAddrs", hostinfo.vpnAddrs,
|
"vpnAddrs", hostinfo.vpnAddrs,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -595,23 +420,19 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
|
|||||||
if remote.IsValid() {
|
if remote.IsValid() {
|
||||||
err = f.writers[q].WriteTo(out, remote)
|
err = f.writers[q].WriteTo(out, remote)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok {
|
hostinfo.logger(f.l).Error("Failed to write outgoing packet",
|
||||||
hostinfo.logger(l).Error("Failed to write outgoing packet",
|
|
||||||
"error", err,
|
"error", err,
|
||||||
"udpAddr", remote,
|
"udpAddr", remote,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
|
||||||
} else if hr := hostinfo.GetRemote(); hr.IsValid() {
|
} else if hr := hostinfo.GetRemote(); hr.IsValid() {
|
||||||
err = f.writers[q].WriteTo(out, hr)
|
err = f.writers[q].WriteTo(out, hr)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok {
|
hostinfo.logger(f.l).Error("Failed to write outgoing packet",
|
||||||
hostinfo.logger(l).Error("Failed to write outgoing packet",
|
|
||||||
"error", err,
|
"error", err,
|
||||||
"udpAddr", hr,
|
"udpAddr", hr,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
|
||||||
} else {
|
} else {
|
||||||
// Try to send via a relay
|
// Try to send via a relay
|
||||||
for _, relayIP := range hostinfo.relayState.CopyRelayIps() {
|
for _, relayIP := range hostinfo.relayState.CopyRelayIps() {
|
||||||
@@ -624,7 +445,7 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
|
|||||||
)
|
)
|
||||||
continue
|
continue
|
||||||
}
|
}
|
||||||
f.SendVia(relayHostInfo, relay, out, nb, fullOut[:header.Len+len(out)], true, q)
|
f.SendVia(relayHostInfo, relay, out, nb, fullOut[:header.Len+len(out)], true)
|
||||||
break
|
break
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
-265
@@ -1,265 +0,0 @@
|
|||||||
package nebula
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/binary"
|
|
||||||
"io"
|
|
||||||
"net/netip"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/gaissmai/bart"
|
|
||||||
"github.com/slackhq/nebula/firewall"
|
|
||||||
"github.com/slackhq/nebula/iputil"
|
|
||||||
"github.com/slackhq/nebula/overlay/tio"
|
|
||||||
"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() ([]tio.Packet, error) { return nil, 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{},
|
|
||||||
queues: []tio.Queue{tun},
|
|
||||||
}, tun
|
|
||||||
}
|
|
||||||
|
|
||||||
func consumeInside(f *Interface, packet []byte) {
|
|
||||||
f.consumeInsidePacket(tio.Packet{Bytes: packet}, &firewall.ParsedPacket{}, make([]byte, 12), nil, 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", iputil.IPProtocolTCP, 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", iputil.IPProtocolUDP, 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", iputil.IPProtocolICMP, 2, func() []byte { return echoRequest(8) }}
|
|
||||||
icmpv6Echo = l4Proto{"icmpv6", iputil.IPProtocolICMPv6, 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 == iputil.IPProtocolTCP || p.nextHdr == iputil.IPProtocolUDP {
|
|
||||||
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 == iputil.IPProtocolTCP || p.nextHdr == iputil.IPProtocolUDP {
|
|
||||||
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:]))
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
+59
-198
@@ -2,12 +2,11 @@ package nebula
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"context"
|
"context"
|
||||||
"crypto/fips140"
|
|
||||||
"errors"
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
|
"io"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"runtime"
|
|
||||||
"slices"
|
"slices"
|
||||||
"sync"
|
"sync"
|
||||||
"sync/atomic"
|
"sync/atomic"
|
||||||
@@ -15,16 +14,12 @@ import (
|
|||||||
|
|
||||||
"github.com/gaissmai/bart"
|
"github.com/gaissmai/bart"
|
||||||
"github.com/rcrowley/go-metrics"
|
"github.com/rcrowley/go-metrics"
|
||||||
"github.com/slackhq/nebula/util"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/cert"
|
"github.com/slackhq/nebula/cert"
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/firewall"
|
"github.com/slackhq/nebula/firewall"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/overlay"
|
"github.com/slackhq/nebula/overlay"
|
||||||
"github.com/slackhq/nebula/overlay/batch"
|
|
||||||
"github.com/slackhq/nebula/overlay/tio"
|
|
||||||
"github.com/slackhq/nebula/ratelimit"
|
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -54,21 +49,6 @@ type InterfaceConfig struct {
|
|||||||
reQueryWait time.Duration
|
reQueryWait time.Duration
|
||||||
|
|
||||||
ConntrackCacheTimeout time.Duration
|
ConntrackCacheTimeout time.Duration
|
||||||
|
|
||||||
// CpuAffinity, when non-empty, names the CPUs each TUN reader goroutine
|
|
||||||
// should pin to. Queue i pins to CpuAffinity[i % len(CpuAffinity)] —
|
|
||||||
// shorter lists than `routines` cycle. Empty list keeps the default
|
|
||||||
// pin-to-(i % NumCPU) behavior. Only consulted when PinThreads is true.
|
|
||||||
CpuAffinity []int
|
|
||||||
// AvoidCPUs (tun.avoid_cpus) lists CPUs the default pin spread skips when
|
|
||||||
// CpuAffinity is empty. Only consulted when PinThreads is true.
|
|
||||||
AvoidCPUs []int
|
|
||||||
// PinThreads controls whether each TUN reader OS thread is pinned to a
|
|
||||||
// single CPU (via tun.pin_threads, default true). Pinning keeps each
|
|
||||||
// goroutine's sendmmsg on one XPS-selected NIC TX ring so per-flow
|
|
||||||
// packets stay ordered on the wire.
|
|
||||||
PinThreads bool
|
|
||||||
|
|
||||||
l *slog.Logger
|
l *slog.Logger
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -93,17 +73,6 @@ type Interface struct {
|
|||||||
routines int
|
routines int
|
||||||
disconnectInvalid atomic.Bool
|
disconnectInvalid atomic.Bool
|
||||||
closed atomic.Bool
|
closed atomic.Bool
|
||||||
// cpuAffinity, when non-empty, names the CPUs each TUN reader goroutine
|
|
||||||
// should pin to. Queue i pins to cpuAffinity[i % len(cpuAffinity)].
|
|
||||||
// Empty falls back to the default pin-to-(allowed CPU) behavior.
|
|
||||||
// Only consulted when pinThreads is true.
|
|
||||||
cpuAffinity []int
|
|
||||||
// avoidCPUs are removed from that fallback spread, unless they would empty it.
|
|
||||||
avoidCPUs []int
|
|
||||||
// pinThreads controls whether listenIn pins each TUN reader OS thread to
|
|
||||||
// a CPU at all (tun.pin_threads, default true). When false, threads are
|
|
||||||
// left free to migrate as on stock nebula.
|
|
||||||
pinThreads bool
|
|
||||||
relayManager *relayManager
|
relayManager *relayManager
|
||||||
|
|
||||||
tryPromoteEvery atomic.Uint32
|
tryPromoteEvery atomic.Uint32
|
||||||
@@ -113,27 +82,17 @@ type Interface struct {
|
|||||||
sendRecvErrorConfig recvErrorConfig
|
sendRecvErrorConfig recvErrorConfig
|
||||||
acceptRecvErrorConfig recvErrorConfig
|
acceptRecvErrorConfig recvErrorConfig
|
||||||
|
|
||||||
// Bumped on every udp rebind, tunnels compare it to decide they need a punch from the far side
|
// rebindCount is used to decide if an active tunnel should trigger a punch notification through a lighthouse
|
||||||
rebindEpoch atomic.Uint32
|
rebindCount int8
|
||||||
version string
|
version string
|
||||||
|
|
||||||
conntrackCacheTimeout time.Duration
|
conntrackCacheTimeout time.Duration
|
||||||
|
|
||||||
ctx context.Context
|
ctx context.Context
|
||||||
writers []udp.Conn
|
writers []udp.Conn
|
||||||
queues []tio.Queue
|
readers []io.ReadWriteCloser
|
||||||
// batchers is one per tun queue, wrapping queues[i]. readOutsidePackets
|
|
||||||
// commits plaintext into the batcher; the plaintext is decrypted
|
|
||||||
// in place inside the UDP receive buffers, so listenOut must call Flush
|
|
||||||
// at the end of each UDP recvmmsg batch, before those buffers are
|
|
||||||
// reused (every udp.Conn ListenOut guarantees that ordering).
|
|
||||||
batchers []*batch.MultiCoalescer
|
|
||||||
wg sync.WaitGroup
|
wg sync.WaitGroup
|
||||||
|
|
||||||
udpTxErrLimiter *ratelimit.Limiter // udp direct transmit error log limiter
|
|
||||||
udpRelayTxErrLimiter *ratelimit.Limiter // udp relay transmit error log limiter
|
|
||||||
txOversizeLimiter *ratelimit.Limiter // oversized outbound packet drop log limiter
|
|
||||||
|
|
||||||
// fatalErr holds the first unexpected reader error that caused shutdown.
|
// fatalErr holds the first unexpected reader error that caused shutdown.
|
||||||
// nil means "no fatal error" (yet)
|
// nil means "no fatal error" (yet)
|
||||||
fatalErr atomic.Pointer[error]
|
fatalErr atomic.Pointer[error]
|
||||||
@@ -143,13 +102,18 @@ type Interface struct {
|
|||||||
metricHandshakes metrics.Histogram
|
metricHandshakes metrics.Histogram
|
||||||
messageMetrics *MessageMetrics
|
messageMetrics *MessageMetrics
|
||||||
cachedPacketMetrics *cachedPacketMetrics
|
cachedPacketMetrics *cachedPacketMetrics
|
||||||
metricTxDropped metrics.Counter
|
|
||||||
|
|
||||||
l *slog.Logger
|
l *slog.Logger
|
||||||
}
|
}
|
||||||
|
|
||||||
type EncWriter interface {
|
type EncWriter interface {
|
||||||
SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool, q int)
|
SendVia(via *HostInfo,
|
||||||
|
relay *Relay,
|
||||||
|
ad,
|
||||||
|
nb,
|
||||||
|
out []byte,
|
||||||
|
nocopy bool,
|
||||||
|
)
|
||||||
SendMessageToVpnAddr(t header.MessageType, st header.MessageSubType, vpnAddr netip.Addr, p, nb, out []byte)
|
SendMessageToVpnAddr(t header.MessageType, st header.MessageSubType, vpnAddr netip.Addr, p, nb, out []byte)
|
||||||
SendMessageToHostInfo(t header.MessageType, st header.MessageSubType, hostinfo *HostInfo, p, nb, out []byte)
|
SendMessageToHostInfo(t header.MessageType, st header.MessageSubType, hostinfo *HostInfo, p, nb, out []byte)
|
||||||
Handshake(vpnAddr netip.Addr)
|
Handshake(vpnAddr netip.Addr)
|
||||||
@@ -208,23 +172,6 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
|
|||||||
return nil, errors.New("no connection manager")
|
return nil, errors.New("no connection manager")
|
||||||
}
|
}
|
||||||
|
|
||||||
udpTxErrLimiter, err := ratelimit.New(1, time.Second)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
udpRelayTxErrLimiter, err := ratelimit.New(1, time.Second)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
txOversizeLimiter, err := ratelimit.New(1, time.Second)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
if c.routines <= 1 {
|
|
||||||
c.PinThreads = false //pinning is not useful unless there's more than one tun reader
|
|
||||||
}
|
|
||||||
|
|
||||||
cs := c.pki.getCertState()
|
cs := c.pki.getCertState()
|
||||||
ifce := &Interface{
|
ifce := &Interface{
|
||||||
ctx: ctx,
|
ctx: ctx,
|
||||||
@@ -242,7 +189,7 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
|
|||||||
routines: c.routines,
|
routines: c.routines,
|
||||||
version: c.version,
|
version: c.version,
|
||||||
writers: make([]udp.Conn, c.routines),
|
writers: make([]udp.Conn, c.routines),
|
||||||
batchers: make([]*batch.MultiCoalescer, c.routines),
|
readers: make([]io.ReadWriteCloser, c.routines),
|
||||||
myVpnNetworks: cs.myVpnNetworks,
|
myVpnNetworks: cs.myVpnNetworks,
|
||||||
myVpnNetworksTable: cs.myVpnNetworksTable,
|
myVpnNetworksTable: cs.myVpnNetworksTable,
|
||||||
myVpnAddrs: cs.myVpnAddrs,
|
myVpnAddrs: cs.myVpnAddrs,
|
||||||
@@ -251,15 +198,8 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
|
|||||||
relayManager: c.relayManager,
|
relayManager: c.relayManager,
|
||||||
connectionManager: c.connectionManager,
|
connectionManager: c.connectionManager,
|
||||||
conntrackCacheTimeout: c.ConntrackCacheTimeout,
|
conntrackCacheTimeout: c.ConntrackCacheTimeout,
|
||||||
cpuAffinity: c.CpuAffinity,
|
|
||||||
avoidCPUs: c.AvoidCPUs,
|
|
||||||
pinThreads: c.PinThreads,
|
|
||||||
udpTxErrLimiter: udpTxErrLimiter,
|
|
||||||
udpRelayTxErrLimiter: udpRelayTxErrLimiter,
|
|
||||||
txOversizeLimiter: txOversizeLimiter,
|
|
||||||
|
|
||||||
metricHandshakes: metrics.GetOrRegisterHistogram("handshakes", nil, metrics.NewExpDecaySample(1028, 0.015)),
|
metricHandshakes: metrics.GetOrRegisterHistogram("handshakes", nil, metrics.NewExpDecaySample(1028, 0.015)),
|
||||||
metricTxDropped: metrics.GetOrRegisterCounter("udp.tx.dropped", nil),
|
|
||||||
messageMetrics: c.MessageMetrics,
|
messageMetrics: c.MessageMetrics,
|
||||||
cachedPacketMetrics: &cachedPacketMetrics{
|
cachedPacketMetrics: &cachedPacketMetrics{
|
||||||
sent: metrics.GetOrRegisterCounter("hostinfo.cached_packets.sent", nil),
|
sent: metrics.GetOrRegisterCounter("hostinfo.cached_packets.sent", nil),
|
||||||
@@ -298,41 +238,27 @@ func (f *Interface) activate() error {
|
|||||||
"build", f.version,
|
"build", f.version,
|
||||||
"udpAddr", addr,
|
"udpAddr", addr,
|
||||||
"boringcrypto", boringEnabled(),
|
"boringcrypto", boringEnabled(),
|
||||||
"fips140Version", fips140.Version(),
|
|
||||||
"fips140Enabled", fips140.Enabled(),
|
|
||||||
"fips140Enforced", fips140.Enforced(),
|
|
||||||
)
|
)
|
||||||
|
|
||||||
if f.routines > 1 && !f.outside.SupportsMultipleReaders() {
|
if f.routines > 1 {
|
||||||
|
if !f.inside.SupportsMultiqueue() || !f.outside.SupportsMultipleReaders() {
|
||||||
f.routines = 1
|
f.routines = 1
|
||||||
f.l.Warn("multiple udp readers are not supported on this platform, falling back to a single routine")
|
f.l.Warn("routines is not supported on this platform, falling back to a single routine")
|
||||||
}
|
}
|
||||||
|
|
||||||
// Prepare the tun queues. A device that can't open that many hands back
|
|
||||||
// fewer (a single queue on platforms without multiqueue support) and we
|
|
||||||
// size the reader routines to what we actually got.
|
|
||||||
queues, err := f.inside.Queues(f.routines)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
}
|
||||||
if len(queues) < f.routines {
|
|
||||||
// TODO: this clamp is only safe because it is unreachable when the
|
|
||||||
// udp side has multiple readers (linux Queues opens exactly n or
|
|
||||||
// errors; every other platform already clamped routines to 1 above).
|
|
||||||
// If a platform ever returns fewer queues than routines with
|
|
||||||
// SO_REUSEPORT sockets already bound, the surplus sockets get no
|
|
||||||
// listenOut and the kernel blackholes every flow it hashes to them —
|
|
||||||
// fail loudly or close the extra sockets instead.
|
|
||||||
f.l.Warn("tun multiqueue is not supported on this platform, falling back to fewer routines",
|
|
||||||
"requested", f.routines, "opened", len(queues))
|
|
||||||
f.routines = len(queues)
|
|
||||||
}
|
|
||||||
f.queues = queues
|
|
||||||
|
|
||||||
metrics.GetOrRegisterGauge("routines", nil).Update(int64(f.routines))
|
metrics.GetOrRegisterGauge("routines", nil).Update(int64(f.routines))
|
||||||
|
|
||||||
for i := range f.queues {
|
// Prepare n tun queues
|
||||||
f.batchers[i] = batch.NewMultiCoalescer(f.queues[i], f.l)
|
var reader io.ReadWriteCloser = f.inside
|
||||||
|
for i := 0; i < f.routines; i++ {
|
||||||
|
if i > 0 {
|
||||||
|
reader, err = f.inside.NewMultiQueueReader()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
f.readers[i] = reader
|
||||||
}
|
}
|
||||||
|
|
||||||
// On error the caller owns the cleanup, Control.Start cancels the service context
|
// On error the caller owns the cleanup, Control.Start cancels the service context
|
||||||
@@ -355,7 +281,7 @@ func (f *Interface) run() {
|
|||||||
// Launch n queues to read packets from tun dev
|
// Launch n queues to read packets from tun dev
|
||||||
for i := 0; i < f.routines; i++ {
|
for i := 0; i < f.routines; i++ {
|
||||||
f.wg.Go(func() {
|
f.wg.Go(func() {
|
||||||
f.listenIn(f.queues[i], i)
|
f.listenIn(f.readers[i], i)
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -380,31 +306,6 @@ func (f *Interface) onFatal(err error) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
type rxContext struct {
|
|
||||||
q int
|
|
||||||
scratch []byte
|
|
||||||
// nb is a re-usable nonce buffer for decrypt calls to use
|
|
||||||
nb []byte
|
|
||||||
h *header.H
|
|
||||||
fwPacket *firewall.ParsedPacket
|
|
||||||
hostmapCache map[uint32]*HostInfo
|
|
||||||
lhh *LightHouseHandler
|
|
||||||
ctCache *firewall.ConntrackCacheTicker
|
|
||||||
}
|
|
||||||
|
|
||||||
func newRxContext(f *Interface, q int) *rxContext {
|
|
||||||
return &rxContext{
|
|
||||||
q: q,
|
|
||||||
scratch: make([]byte, mtu),
|
|
||||||
nb: make([]byte, 12, 12),
|
|
||||||
h: &header.H{},
|
|
||||||
fwPacket: &firewall.ParsedPacket{},
|
|
||||||
hostmapCache: map[uint32]*HostInfo{},
|
|
||||||
lhh: f.lightHouse.NewRequestHandler(),
|
|
||||||
ctCache: firewall.NewConntrackCacheTicker(f.ctx, f.l, f.conntrackCacheTimeout),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *Interface) listenOut(i int) {
|
func (f *Interface) listenOut(i int) {
|
||||||
var li udp.Conn
|
var li udp.Conn
|
||||||
if i > 0 {
|
if i > 0 {
|
||||||
@@ -413,20 +314,16 @@ func (f *Interface) listenOut(i int) {
|
|||||||
li = f.outside
|
li = f.outside
|
||||||
}
|
}
|
||||||
|
|
||||||
rxc := newRxContext(f, i)
|
ctCache := firewall.NewConntrackCacheTicker(f.ctx, f.l, f.conntrackCacheTimeout)
|
||||||
|
lhh := f.lightHouse.NewRequestHandler()
|
||||||
|
plaintext := make([]byte, udp.MTU)
|
||||||
|
h := &header.H{}
|
||||||
|
fwPacket := &firewall.Packet{}
|
||||||
|
nb := make([]byte, 12, 12)
|
||||||
|
|
||||||
listener := func(fromUdpAddr netip.AddrPort, payload []byte) {
|
err := li.ListenOut(func(fromUdpAddr netip.AddrPort, payload []byte) {
|
||||||
f.readOutsidePackets(ViaSender{UdpAddr: fromUdpAddr}, payload, rxc)
|
f.readOutsidePackets(ViaSender{UdpAddr: fromUdpAddr}, plaintext[:0], payload, h, fwPacket, lhh, nb, i, ctCache.Get())
|
||||||
}
|
})
|
||||||
|
|
||||||
flusher := func() {
|
|
||||||
if err := f.batchers[i].Flush(); err != nil {
|
|
||||||
f.l.Error("Failed to flush tun coalescer", "error", err)
|
|
||||||
}
|
|
||||||
clear(rxc.hostmapCache)
|
|
||||||
}
|
|
||||||
|
|
||||||
err := li.ListenOut(listener, flusher)
|
|
||||||
|
|
||||||
// An error after teardown began is shutdown noise, the closed flag covers resources
|
// An error after teardown began is shutdown noise, the closed flag covers resources
|
||||||
// Close releases itself and the cancelled ctx covers ones torn down by their owners
|
// Close releases itself and the cancelled ctx covers ones torn down by their owners
|
||||||
@@ -439,44 +336,16 @@ func (f *Interface) listenOut(i int) {
|
|||||||
f.l.Debug("underlay reader is done", "reader", i)
|
f.l.Debug("underlay reader is done", "reader", i)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) pinThisThread(i int) {
|
func (f *Interface) listenIn(reader io.ReadWriteCloser, i int) {
|
||||||
var cpu int
|
packet := make([]byte, mtu)
|
||||||
if n := len(f.cpuAffinity); n > 0 {
|
out := make([]byte, mtu)
|
||||||
// Explicit tun.cpu_affinity list wins; parseCpuAffinity already
|
fwPacket := &firewall.Packet{}
|
||||||
// validated the entries against the allowed CPU set and tun.avoid_cpus.
|
|
||||||
cpu = f.cpuAffinity[i%n]
|
|
||||||
} else if allowed, err := util.AllowedCPUs(); err == nil && len(allowed) > 0 {
|
|
||||||
// Default: spread queues across the CPUs we're actually allowed to
|
|
||||||
// run on. Under a cpuset/taskset mask these aren't 0..NumCPU-1, so
|
|
||||||
// i % NumCPU would pick unrunnable IDs and every pin would fail.
|
|
||||||
// parseAvoidCPUs already dropped an avoid list that covers them all.
|
|
||||||
allowed = slices.DeleteFunc(allowed, func(c int) bool { return slices.Contains(f.avoidCPUs, c) })
|
|
||||||
cpu = allowed[i%len(allowed)]
|
|
||||||
} else {
|
|
||||||
cpu = i % runtime.NumCPU()
|
|
||||||
}
|
|
||||||
if err := util.PinThreadToCPU(cpu); err != nil {
|
|
||||||
f.l.Warn("failed to pin tun reader to CPU", "queue", i, "cpu", cpu, "err", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *Interface) listenIn(queue tio.Queue, i int) {
|
|
||||||
// Pinning this thread (and goroutine) to a single CPU keeps every sendmmsg from this goroutine going through the
|
|
||||||
// same TX ring on the nic, so the wire sees per-flow order. Skip entirely when tun.pin_threads is false.
|
|
||||||
if f.pinThreads {
|
|
||||||
f.pinThisThread(i)
|
|
||||||
}
|
|
||||||
|
|
||||||
rejectBuf := make([]byte, mtu)
|
|
||||||
arenaSize := batch.SendBatchCap * (udp.MTU + 32)
|
|
||||||
sb := batch.NewSendBatch(f.writers[i], batch.SendBatchCap, arenaSize)
|
|
||||||
fwPacket := &firewall.ParsedPacket{}
|
|
||||||
nb := make([]byte, 12, 12)
|
nb := make([]byte, 12, 12)
|
||||||
|
|
||||||
conntrackCache := firewall.NewConntrackCacheTicker(f.ctx, f.l, f.conntrackCacheTimeout)
|
conntrackCache := firewall.NewConntrackCacheTicker(f.ctx, f.l, f.conntrackCacheTimeout)
|
||||||
|
|
||||||
for {
|
for {
|
||||||
pkts, err := queue.Read()
|
n, err := reader.Read(packet)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
// Same shutdown noise handling as listenOut
|
// Same shutdown noise handling as listenOut
|
||||||
if !f.closed.Load() && f.ctx.Err() == nil {
|
if !f.closed.Load() && f.ctx.Err() == nil {
|
||||||
@@ -486,35 +355,12 @@ func (f *Interface) listenIn(queue tio.Queue, i int) {
|
|||||||
break
|
break
|
||||||
}
|
}
|
||||||
|
|
||||||
for _, pkt := range pkts {
|
f.consumeInsidePacket(packet[:n], fwPacket, nb, out, i, conntrackCache.Get())
|
||||||
f.consumeInsidePacket(pkt, fwPacket, nb, sb, rejectBuf, i, conntrackCache.Get())
|
|
||||||
// Flush incrementally once a full sendmmsg batch has
|
|
||||||
// accumulated so the first packets of a deep read drain
|
|
||||||
// hit the wire while the rest are still being encrypted.
|
|
||||||
if sb.Len() >= batch.SendBatchCap {
|
|
||||||
f.flushSendBatch(sb, i)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
f.flushSendBatch(sb, i)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
f.l.Debug("overlay reader is done", "reader", i)
|
f.l.Debug("overlay reader is done", "reader", i)
|
||||||
}
|
}
|
||||||
|
|
||||||
// flushSendBatch drains sb to the underlay and accounts for anything it could not deliver. A shortfall means
|
|
||||||
// specific destinations were undeliverable (a stale remote, a reject rule), which the backend logs per peer at
|
|
||||||
// debug; here it is only a counter, so one unreachable peer cannot spam a log line per batch.
|
|
||||||
func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) {
|
|
||||||
queued := sb.Len()
|
|
||||||
written, err := sb.Flush()
|
|
||||||
if err != nil {
|
|
||||||
f.l.Error("Failed to write outgoing batch", "error", err, "writer", q)
|
|
||||||
}
|
|
||||||
if dropped := queued - written; dropped > 0 {
|
|
||||||
f.metricTxDropped.Inc(int64(dropped))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *Interface) RegisterConfigChangeCallbacks(c *config.C) {
|
func (f *Interface) RegisterConfigChangeCallbacks(c *config.C) {
|
||||||
c.RegisterReloadCallback(f.reloadFirewall)
|
c.RegisterReloadCallback(f.reloadFirewall)
|
||||||
c.RegisterReloadCallback(f.reloadSendRecvError)
|
c.RegisterReloadCallback(f.reloadSendRecvError)
|
||||||
@@ -653,15 +499,17 @@ func (f *Interface) reloadMisc(c *config.C) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// statsEmitter updates the interface's gauges, the stats server runs it on its capture loop.
|
func (f *Interface) emitStats(ctx context.Context, i time.Duration) {
|
||||||
func (f *Interface) statsEmitter() func() {
|
ticker := time.NewTicker(i)
|
||||||
|
defer ticker.Stop()
|
||||||
|
|
||||||
udpStats := udp.NewUDPStatsEmitter(f.writers)
|
udpStats := udp.NewUDPStatsEmitter(f.writers)
|
||||||
|
|
||||||
certExpirationGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil)
|
certExpirationGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil)
|
||||||
certInitiatingVersion := metrics.GetOrRegisterGauge("certificate.initiating_version", nil)
|
certInitiatingVersion := metrics.GetOrRegisterGauge("certificate.initiating_version", nil)
|
||||||
certMaxVersion := metrics.GetOrRegisterGauge("certificate.max_version", nil)
|
certMaxVersion := metrics.GetOrRegisterGauge("certificate.max_version", nil)
|
||||||
|
|
||||||
return func() {
|
emit := func() {
|
||||||
f.firewall.EmitStats()
|
f.firewall.EmitStats()
|
||||||
f.handshakeManager.EmitStats()
|
f.handshakeManager.EmitStats()
|
||||||
udpStats()
|
udpStats()
|
||||||
@@ -678,6 +526,19 @@ func (f *Interface) statsEmitter() func() {
|
|||||||
certMaxVersion.Update(int64(certState.v1Cert.Version()))
|
certMaxVersion.Update(int64(certState.v1Cert.Version()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Prime gauges so a Prometheus scrape that lands before the first tick
|
||||||
|
// sees real values instead of the zero defaults (issue #907).
|
||||||
|
emit()
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-ctx.Done():
|
||||||
|
return
|
||||||
|
case <-ticker.C:
|
||||||
|
emit()
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) GetHostInfo(vpnIp netip.Addr) *HostInfo {
|
func (f *Interface) GetHostInfo(vpnIp netip.Addr) *HostInfo {
|
||||||
|
|||||||
+14
-5
@@ -3,6 +3,7 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"context"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
@@ -17,8 +18,11 @@ import (
|
|||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
)
|
)
|
||||||
|
|
||||||
// Priming before the first tick (issue #907) is Start's job, see TestStatsServer_Start_primes.
|
// Test_emitStats_primesGauges covers issue #907: a Prometheus scrape that
|
||||||
func Test_statsEmitter_setsGauges(t *testing.T) {
|
// landed before the first ticker fire used to read 0 for the cert gauges.
|
||||||
|
// emitStats now primes the gauges before entering the ticker loop. We assert
|
||||||
|
// the gauge is zero before the first call and non-zero after.
|
||||||
|
func Test_emitStats_primesGauges(t *testing.T) {
|
||||||
defer metrics.DefaultRegistry.UnregisterAll()
|
defer metrics.DefaultRegistry.UnregisterAll()
|
||||||
|
|
||||||
l := test.NewLogger()
|
l := test.NewLogger()
|
||||||
@@ -52,12 +56,17 @@ func Test_statsEmitter_setsGauges(t *testing.T) {
|
|||||||
ifce.pki.cs.Store(cs)
|
ifce.pki.cs.Store(cs)
|
||||||
|
|
||||||
ttlGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil)
|
ttlGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil)
|
||||||
require.Zero(t, ttlGauge.Value(), "gauge should be zero before the emitter runs")
|
require.Zero(t, ttlGauge.Value(), "gauge should be zero before emitStats runs")
|
||||||
|
|
||||||
ifce.statsEmitter()()
|
// Pre-cancel the context so emitStats returns after priming the gauges
|
||||||
|
// without ever reading from ticker.C. The one hour interval is just a
|
||||||
|
// belt-and-suspenders, the test does not expect the ticker to fire.
|
||||||
|
ctx, cancel := context.WithCancel(context.Background())
|
||||||
|
cancel()
|
||||||
|
ifce.emitStats(ctx, time.Hour)
|
||||||
|
|
||||||
ttl := ttlGauge.Value()
|
ttl := ttlGauge.Value()
|
||||||
assert.Positive(t, ttl, "ttl gauge should be set by one run of the emitter")
|
assert.Positive(t, ttl, "ttl gauge should be primed by emitStats before its first tick")
|
||||||
assert.LessOrEqual(t, ttl, int64(3600))
|
assert.LessOrEqual(t, ttl, int64(3600))
|
||||||
assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.initiating_version", nil).Value())
|
assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.initiating_version", nil).Value())
|
||||||
assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.max_version", nil).Value())
|
assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.max_version", nil).Value())
|
||||||
|
|||||||
@@ -7,7 +7,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/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/slackhq/nebula/util"
|
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
)
|
)
|
||||||
@@ -119,22 +118,3 @@ func TestReloadFirewall_NoChange(t *testing.T) {
|
|||||||
|
|
||||||
assert.Same(t, fw, f.firewall, "firewall should not have been replaced")
|
assert.Same(t, fw, f.firewall, "firewall should not have been replaced")
|
||||||
}
|
}
|
||||||
|
|
||||||
// TestPinThisThreadFallbackSkipsAvoided covers the single reader, which never goes through cpupick: its fallback
|
|
||||||
// spread over the allowed set must still skip tun.avoid_cpus.
|
|
||||||
func TestPinThisThreadFallbackSkipsAvoided(t *testing.T) {
|
|
||||||
allowed, err := util.AllowedCPUs()
|
|
||||||
require.NoError(t, err)
|
|
||||||
if len(allowed) < 2 {
|
|
||||||
t.Skip("requires at least two allowed CPUs")
|
|
||||||
}
|
|
||||||
f := &Interface{l: test.NewLogger(), pinThreads: true, avoidCPUs: []int{allowed[0]}}
|
|
||||||
got := make(chan []int)
|
|
||||||
go func() {
|
|
||||||
// The pin leaves this goroutine locked to its thread, so the runtime discards the thread when it returns.
|
|
||||||
f.pinThisThread(0)
|
|
||||||
cpus, _ := util.AllowedCPUs()
|
|
||||||
got <- cpus
|
|
||||||
}()
|
|
||||||
assert.Equal(t, []int{allowed[1]}, <-got)
|
|
||||||
}
|
|
||||||
@@ -1,136 +0,0 @@
|
|||||||
package iputil
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/binary"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/overlay/checksum"
|
|
||||||
"golang.org/x/net/ipv4"
|
|
||||||
"golang.org/x/net/ipv6"
|
|
||||||
)
|
|
||||||
|
|
||||||
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
|
|
||||||
}
|
|
||||||
// do not attempt to set checksums for fragments
|
|
||||||
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, 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
|
|
||||||
}
|
|
||||||
|
|
||||||
// we must find the transport header in order to write a checksum
|
|
||||||
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, 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 proto != 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 uint8, csum uint32) {
|
|
||||||
var at, minLen int
|
|
||||||
switch proto {
|
|
||||||
case IPProtocolTCP:
|
|
||||||
at, minLen = 16, 20
|
|
||||||
case 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 == IPProtocolUDP {
|
|
||||||
sum = 0xffff
|
|
||||||
}
|
|
||||||
binary.BigEndian.PutUint16(transport[at:], sum)
|
|
||||||
}
|
|
||||||
|
|
||||||
func fold(csum uint32) uint16 {
|
|
||||||
for csum > 0xffff {
|
|
||||||
csum = (csum >> 16) + (csum & 0xffff)
|
|
||||||
}
|
|
||||||
return uint16(csum)
|
|
||||||
}
|
|
||||||
@@ -1,242 +0,0 @@
|
|||||||
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))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
+20
-27
@@ -27,13 +27,6 @@ const (
|
|||||||
maxIPv6RejectPacketSize = ipv6.HeaderLen + 8 + 1000
|
maxIPv6RejectPacketSize = ipv6.HeaderLen + 8 + 1000
|
||||||
|
|
||||||
MaxRejectPacketSize = maxIPv6RejectPacketSize
|
MaxRejectPacketSize = maxIPv6RejectPacketSize
|
||||||
|
|
||||||
IPProtocolICMP = 1
|
|
||||||
IPProtocolICMPv6 = 58
|
|
||||||
IPProtocolTCP = 6
|
|
||||||
IPProtocolUDP = 17
|
|
||||||
ICMPv6TypeEchoRequest = 128
|
|
||||||
ICMPv6TypeEchoReply = 129
|
|
||||||
)
|
)
|
||||||
|
|
||||||
func CreateRejectPacket(packet []byte, out []byte) []byte {
|
func CreateRejectPacket(packet []byte, out []byte) []byte {
|
||||||
@@ -211,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
|
||||||
}
|
}
|
||||||
@@ -345,57 +338,57 @@ func ipv6CreateRejectTCPPacket(packet []byte, out []byte, offset int) []byte {
|
|||||||
return out
|
return out
|
||||||
}
|
}
|
||||||
|
|
||||||
// IPv6FindUpperProtocol walks the ipv6 extension header chain and returns the upper layer protocol, the offset it begins at, and whether the packet is a non-first fragment.
|
// IPv6FindUpperProtocol walks the ipv6 extension header chain and returns the upper layer protocol, the
|
||||||
// Only the RFC 8200 and IANA extension headers below are walked.
|
// offset it begins at, and whether the packet is a non-first fragment. Only the RFC 8200 and IANA extension
|
||||||
// Everything else, including Mobility (135), HIP (139), Shim6 (140), experimental 253/254, and real upper layer protocols like SCTP or GRE, is terminal.
|
// headers below are walked. Everything else, including Mobility (135), HIP (139), Shim6 (140), experimental
|
||||||
// For a non-first fragment the returned protocol is the fragmented protocol and offset points at the fragment header, there is no transport header to locate.
|
// 253/254, and real upper layer protocols like SCTP or GRE, is terminal. Walking those as extension headers
|
||||||
// Returns ErrIPv6CouldNotFindPayload if packet is smaller than an ipv6 header, or the chain is truncated, or if more than 8 extension headers are present.
|
// is a firewall bypass, so they fail closed. For a non-first fragment the returned protocol is the fragmented
|
||||||
func IPv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragment bool, anyFragment bool, err error) {
|
// protocol and offset points at the fragment header, there is no transport header to locate. Returns
|
||||||
const maxIPv6ExtHeaders = 8
|
// ErrIPv6CouldNotFindPayload if packet is smaller than an ipv6 header or the chain is truncated before a
|
||||||
|
// terminal protocol is reached.
|
||||||
|
func IPv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragment bool, err error) {
|
||||||
if len(packet) < ipv6.HeaderLen {
|
if len(packet) < ipv6.HeaderLen {
|
||||||
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
return 0, 0, false, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
nextHeader = packet[6]
|
nextHeader = packet[6]
|
||||||
offset = ipv6.HeaderLen
|
offset = ipv6.HeaderLen
|
||||||
|
|
||||||
for range maxIPv6ExtHeaders {
|
for {
|
||||||
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 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
return nextHeader, offset, isFragment, 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 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
return nextHeader, offset, isFragment, 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, anyFragment, nil
|
return packet[offset], offset, true, 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 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
return nextHeader, offset, isFragment, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
nextHeader = packet[offset]
|
nextHeader = packet[offset]
|
||||||
offset += (int(packet[offset+1]) + 2) << 2
|
offset += (int(packet[offset+1]) + 2) << 2
|
||||||
|
|
||||||
default:
|
default:
|
||||||
|
// 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.
|
||||||
if offset > len(packet) {
|
if offset > len(packet) {
|
||||||
// A prior extension header can declare a length that advances offset past the packet, reject this.
|
return nextHeader, offset, isFragment, ErrIPv6CouldNotFindPayload
|
||||||
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
|
||||||
}
|
}
|
||||||
return nextHeader, offset, isFragment, anyFragment, nil //success!
|
return nextHeader, offset, isFragment, nil
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// Fail closed
|
|
||||||
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func CreateICMPEchoResponse(packet, out []byte) []byte {
|
func CreateICMPEchoResponse(packet, out []byte) []byte {
|
||||||
|
|||||||
+16
-71
@@ -1,7 +1,6 @@
|
|||||||
package iputil
|
package iputil
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
"net"
|
"net"
|
||||||
"testing"
|
"testing"
|
||||||
@@ -181,46 +180,6 @@ func Test_CreateRejectPacket_NoICMPError(t *testing.T) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Test_CreateRejectPacket_RespectsCap ensures it is impossible for
|
|
||||||
// an oversized ICMPv6 reject to overwrite the neighbor segment's bytes.
|
|
||||||
func Test_CreateRejectPacket_RespectsCap(t *testing.T) {
|
|
||||||
src := net.ParseIP("fd00::1")
|
|
||||||
dst := net.ParseIP("fd00::2")
|
|
||||||
|
|
||||||
// Inner IPv6 UDP packet. An ICMPv6 reject copies the whole inner packet
|
|
||||||
// plus a 48-byte header (40 IPv6 + 8 ICMPv6), so it needs 48 more bytes
|
|
||||||
// than the inner packet length.
|
|
||||||
inner := makeIPv6Packet(src, dst, 17, make([]byte, 20))
|
|
||||||
|
|
||||||
// The ciphertext scratch reused as the reject buffer is the received
|
|
||||||
// datagram: 16-byte Nebula header + inner + 16-byte AEAD tag. That is only
|
|
||||||
// 32 bytes of slack, so a full ICMPv6 reject overruns it by 16 bytes.
|
|
||||||
const nebulaOverhead = 32
|
|
||||||
segLen := len(inner) + nebulaOverhead
|
|
||||||
|
|
||||||
// Shared backing row laid out as [segment][neighbor's 16-byte Nebula header].
|
|
||||||
const neighborHdr = 16
|
|
||||||
sentinel := bytes.Repeat([]byte{0xAB}, neighborHdr)
|
|
||||||
|
|
||||||
// Uncapped: the slice's capacity reaches into the neighbor, reproducing
|
|
||||||
// the overrun that silently drops the neighbor packet.
|
|
||||||
backing := make([]byte, segLen+neighborHdr)
|
|
||||||
copy(backing[segLen:], sentinel)
|
|
||||||
reject := CreateRejectPacket(inner, backing[:segLen])
|
|
||||||
assert.NotNil(t, reject, "uncapped buffer reaches into the neighbor, so the reject is built")
|
|
||||||
assert.NotEqual(t, sentinel, backing[segLen:segLen+neighborHdr],
|
|
||||||
"without the cap the oversized reject overruns into the neighbor segment")
|
|
||||||
|
|
||||||
// Capped (the fix): cap==len, so the builder cannot exceed the segment. The
|
|
||||||
// reject does not fit, so it is refused rather than corrupting the neighbor.
|
|
||||||
backing = make([]byte, segLen+neighborHdr)
|
|
||||||
copy(backing[segLen:], sentinel)
|
|
||||||
reject = CreateRejectPacket(inner, backing[:segLen:segLen])
|
|
||||||
assert.Nil(t, reject, "capped segment is 16 bytes too small for a full ICMPv6 reject, so it is refused")
|
|
||||||
assert.Equal(t, sentinel, backing[segLen:segLen+neighborHdr],
|
|
||||||
"capped segment must leave the neighbor untouched")
|
|
||||||
}
|
|
||||||
|
|
||||||
func makeIPv6Packet(src, dst net.IP, nextHeader uint8, payload []byte) []byte {
|
func makeIPv6Packet(src, dst net.IP, nextHeader uint8, payload []byte) []byte {
|
||||||
b := make([]byte, ipv6.HeaderLen+len(payload))
|
b := make([]byte, ipv6.HeaderLen+len(payload))
|
||||||
b[0] = ipv6.Version << 4
|
b[0] = ipv6.Version << 4
|
||||||
@@ -529,17 +488,6 @@ func Test_IPv6FindUpperProtocol(t *testing.T) {
|
|||||||
firstFragToUDP := []byte{17, 0, 0, 1, 0, 0, 0, 1} // frag offset 0, M=1, next = UDP
|
firstFragToUDP := []byte{17, 0, 0, 1, 0, 0, 0, 1} // frag offset 0, M=1, next = UDP
|
||||||
nonFirstFrag := []byte{17, 0, 0, 9, 0, 0, 0, 1} // frag offset non-zero, next = UDP
|
nonFirstFrag := []byte{17, 0, 0, 9, 0, 0, 0, 1} // frag offset non-zero, next = UDP
|
||||||
transport := []byte{0, 80, 1, 187, 0, 0, 0, 0} // stand-in bytes, IPv6FindUpperProtocol never reads ports
|
transport := []byte{0, 80, 1, 187, 0, 0, 0, 0} // stand-in bytes, IPv6FindUpperProtocol never reads ports
|
||||||
extToHbH := []byte{0, 0, 0, 0, 0, 0, 0, 0} // len 0 -> 8 bytes, next = Hop-by-Hop
|
|
||||||
|
|
||||||
// 8 walked headers spend the budget before the 9th slot's terminal is ever classified. This is the
|
|
||||||
// report 4040546 shape: without failing closed the walk hands back offset 104, and a caller reads ports
|
|
||||||
// from the attacker's bytes there.
|
|
||||||
var budgetChain []byte
|
|
||||||
for range 7 {
|
|
||||||
budgetChain = append(budgetChain, extToHbH...)
|
|
||||||
}
|
|
||||||
budgetChain = append(budgetChain, extToTCP...)
|
|
||||||
budgetChain = append(budgetChain, transport...)
|
|
||||||
|
|
||||||
tests := []struct {
|
tests := []struct {
|
||||||
name string
|
name string
|
||||||
@@ -548,43 +496,40 @@ 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, false, nil},
|
{"plain udp", 17, transport, 17, ipv6.HeaderLen, false, nil},
|
||||||
{"hop-by-hop then tcp", 0, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, false, nil},
|
{"hop-by-hop then tcp", 0, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, nil},
|
||||||
{"routing then tcp", 43, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, false, nil},
|
{"routing then tcp", 43, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, nil},
|
||||||
{"destination then udp", 60, append(extToUDP, transport...), 17, ipv6.HeaderLen + 8, false, false, nil},
|
{"destination then udp", 60, append(extToUDP, transport...), 17, ipv6.HeaderLen + 8, false, nil},
|
||||||
{"hop-by-hop, routing, then tcp", 0, append(append(extToRouting, extToTCP...), transport...), 6, ipv6.HeaderLen + 16, false, false, nil},
|
{"hop-by-hop, routing, then tcp", 0, append(append(extToRouting, extToTCP...), transport...), 6, ipv6.HeaderLen + 16, false, nil},
|
||||||
{"ah then udp", 51, append(ahToUDP, transport...), 17, ipv6.HeaderLen + 8, false, false, nil},
|
{"ah then udp", 51, append(ahToUDP, transport...), 17, ipv6.HeaderLen + 8, false, nil},
|
||||||
{"first fragment walks to transport", 44, append(firstFragToUDP, transport...), 17, ipv6.HeaderLen + 8, false, true, nil},
|
{"first fragment walks to transport", 44, append(firstFragToUDP, transport...), 17, ipv6.HeaderLen + 8, false, nil},
|
||||||
{"non-first fragment stops", 44, append(nonFirstFrag, transport...), 17, ipv6.HeaderLen, true, true, nil},
|
{"non-first fragment stops", 44, append(nonFirstFrag, transport...), 17, ipv6.HeaderLen, true, nil},
|
||||||
{"unknown protocol is terminal", 132, transport, 132, ipv6.HeaderLen, false, false, nil}, // SCTP
|
{"unknown protocol is terminal", 132, transport, 132, ipv6.HeaderLen, false, nil}, // SCTP
|
||||||
{"truncated extension header", 0, nil, 0, 0, false, false, ErrIPv6CouldNotFindPayload},
|
{"truncated extension header", 0, nil, 0, ipv6.HeaderLen, 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", 0, []byte{132, 255, 0, 0, 0, 0, 0, 0}, 0, 0, false, false, ErrIPv6CouldNotFindPayload},
|
{"extension length past buffer", 60, []byte{132, 255, 0, 0, 0, 0, 0, 0}, 132, ipv6.HeaderLen + 2048, false, ErrIPv6CouldNotFindPayload},
|
||||||
{"budget exhausted fails closed", 0, budgetChain, 0, 0, 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, anyFragment, err := IPv6FindUpperProtocol(packet)
|
proto, offset, isFragment, err := IPv6FindUpperProtocol(packet)
|
||||||
if tt.wantErr != nil {
|
if tt.wantErr != nil {
|
||||||
require.ErrorIs(t, err, tt.wantErr)
|
assert.ErrorIs(t, err, tt.wantErr)
|
||||||
} else {
|
return
|
||||||
require.NoError(t, err)
|
|
||||||
}
|
}
|
||||||
|
require.NoError(t, err)
|
||||||
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)
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
+6
-70
@@ -15,12 +15,10 @@ import (
|
|||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/gaissmai/bart"
|
"github.com/gaissmai/bart"
|
||||||
"github.com/rcrowley/go-metrics"
|
|
||||||
"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"
|
"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"
|
||||||
)
|
)
|
||||||
@@ -36,18 +34,12 @@ type LightHouse struct {
|
|||||||
|
|
||||||
myVpnNetworks []netip.Prefix
|
myVpnNetworks []netip.Prefix
|
||||||
myVpnNetworksTable *bart.Lite
|
myVpnNetworksTable *bart.Lite
|
||||||
// myVpnAddrsTable contains our overlay host addrs, as opposed to the overlay networks
|
|
||||||
myVpnAddrsTable *bart.Lite
|
|
||||||
punchy *Punchy
|
punchy *Punchy
|
||||||
|
|
||||||
// localAddrsFn enumerates the underlay addresses we advertise. It is a field so tests can supply simulated
|
// localAddrsFn enumerates the underlay addresses we advertise. It is a field so tests can supply simulated
|
||||||
// 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
|
||||||
@@ -82,8 +74,6 @@ type LightHouse struct {
|
|||||||
|
|
||||||
updateTrigger chan struct{}
|
updateTrigger chan struct{}
|
||||||
queryChan chan netip.Addr
|
queryChan chan netip.Addr
|
||||||
// queryDropped counts queries QueryServer dropped because queryChan was full.
|
|
||||||
queryDropped metrics.Counter
|
|
||||||
|
|
||||||
calculatedRemotes atomic.Pointer[bart.Table[[]*calculatedRemote]] // Maps VpnAddr to []*calculatedRemote
|
calculatedRemotes atomic.Pointer[bart.Table[[]*calculatedRemote]] // Maps VpnAddr to []*calculatedRemote
|
||||||
|
|
||||||
@@ -114,19 +104,15 @@ func NewLightHouseFromConfig(ctx context.Context, l *slog.Logger, c *config.C, c
|
|||||||
amLighthouse: amLighthouse,
|
amLighthouse: amLighthouse,
|
||||||
myVpnNetworks: cs.myVpnNetworks,
|
myVpnNetworks: cs.myVpnNetworks,
|
||||||
myVpnNetworksTable: cs.myVpnNetworksTable,
|
myVpnNetworksTable: cs.myVpnNetworksTable,
|
||||||
myVpnAddrsTable: cs.myVpnAddrsTable,
|
|
||||||
addrMap: make(map[netip.Addr]*RemoteList),
|
addrMap: make(map[netip.Addr]*RemoteList),
|
||||||
nebulaPort: nebulaPort,
|
nebulaPort: nebulaPort,
|
||||||
punchy: p,
|
punchy: p,
|
||||||
updateTrigger: make(chan struct{}, 1),
|
updateTrigger: make(chan struct{}, 1),
|
||||||
queryChan: make(chan netip.Addr, c.GetUint32("handshakes.query_buffer", 1024)),
|
queryChan: make(chan netip.Addr, c.GetUint32("handshakes.query_buffer", 64)),
|
||||||
queryDropped: metrics.GetOrRegisterCounter("lighthouse.query.dropped", nil),
|
|
||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
h.localAddrsFn = func(al *LocalAllowList) []netip.Addr {
|
h.localAddrsFn = func(al *LocalAllowList) []netip.Addr {
|
||||||
addrs, err := nicfinder.Find(ctx, h.l, al)
|
return localAddrs(h.l, al)
|
||||||
h.logLocalAddrsErr(err)
|
|
||||||
return addrs
|
|
||||||
}
|
}
|
||||||
|
|
||||||
lighthouses := make([]netip.Addr, 0)
|
lighthouses := make([]netip.Addr, 0)
|
||||||
@@ -359,13 +345,7 @@ func (lh *LightHouse) reload(c *config.C, initial bool) error {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// am_relay decides whether relay.relays applies to us at all
|
if initial || c.HasChanged("relay.relays") {
|
||||||
if initial || c.HasChanged("relay.relays") || c.HasChanged("relay.am_relay") {
|
|
||||||
var before []netip.Addr
|
|
||||||
if !initial {
|
|
||||||
before = lh.GetRelaysForMe()
|
|
||||||
}
|
|
||||||
|
|
||||||
switch c.GetBool("relay.am_relay", false) {
|
switch c.GetBool("relay.am_relay", false) {
|
||||||
case true:
|
case true:
|
||||||
// Relays aren't allowed to specify other relays
|
// Relays aren't allowed to specify other relays
|
||||||
@@ -390,11 +370,6 @@ func (lh *LightHouse) reload(c *config.C, initial bool) error {
|
|||||||
}
|
}
|
||||||
lh.relaysForMe.Store(&relaysForMe)
|
lh.relaysForMe.Store(&relaysForMe)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Tell the lighthouses now rather than at the next interval, but only when what we advertise changed
|
|
||||||
if !initial && !slices.Equal(before, lh.GetRelaysForMe()) {
|
|
||||||
lh.TriggerUpdate()
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return nil
|
return nil
|
||||||
@@ -527,19 +502,14 @@ func (lh *LightHouse) Query(vpnAddr netip.Addr) *RemoteList {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// QueryServer is asynchronous and non-blocking, no reply should be expected.
|
// QueryServer is asynchronous so no reply should be expected
|
||||||
// If the query channel is full, the query is dropped.
|
|
||||||
func (lh *LightHouse) QueryServer(vpnAddr netip.Addr) {
|
func (lh *LightHouse) QueryServer(vpnAddr netip.Addr) {
|
||||||
// Don't put lighthouse addrs in the query channel because we can't query lighthouses about lighthouses
|
// Don't put lighthouse addrs in the query channel because we can't query lighthouses about lighthouses
|
||||||
if lh.amLighthouse || lh.IsLighthouseAddr(vpnAddr) {
|
if lh.amLighthouse || lh.IsLighthouseAddr(vpnAddr) {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
select {
|
lh.queryChan <- vpnAddr
|
||||||
case lh.queryChan <- vpnAddr:
|
|
||||||
default:
|
|
||||||
lh.queryDropped.Inc(1)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (lh *LightHouse) QueryCache(vpnAddrs []netip.Addr) *RemoteList {
|
func (lh *LightHouse) QueryCache(vpnAddrs []netip.Addr) *RemoteList {
|
||||||
@@ -943,26 +913,6 @@ func (lh *LightHouse) TriggerUpdate() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// logLocalAddrsErr reports a localAddrs failure at Warn the first time it is seen and at Debug while
|
|
||||||
// it persists unchanged, so a permanent failure does not warn on every update forever.
|
|
||||||
func (lh *LightHouse) logLocalAddrsErr(err error) {
|
|
||||||
if err == nil {
|
|
||||||
lh.lastLocalAddrsErr.Store(nil)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
msg := err.Error()
|
|
||||||
prev := lh.lastLocalAddrsErr.Swap(&msg)
|
|
||||||
if prev != nil && *prev == msg {
|
|
||||||
if lh.l.Enabled(context.Background(), slog.LevelDebug) {
|
|
||||||
lh.l.Debug("Failed to collect local addresses to advertise", "error", err)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
lh.l.Warn("Failed to collect local addresses to advertise", "error", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (lh *LightHouse) SendUpdate() {
|
func (lh *LightHouse) SendUpdate() {
|
||||||
var v4 []*V4AddrPort
|
var v4 []*V4AddrPort
|
||||||
var v6 []*V6AddrPort
|
var v6 []*V6AddrPort
|
||||||
@@ -1208,17 +1158,6 @@ func (lhh *LightHouseHandler) handleHostQuery(n *NebulaMeta, fromVpnAddrs []neti
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
// Don't respond to requests for us.
|
|
||||||
if lhh.lh.myVpnAddrsTable.Contains(queryVpnAddr) {
|
|
||||||
if lhh.l.Enabled(context.Background(), slog.LevelDebug) {
|
|
||||||
lhh.l.Debug("Ignoring HostQuery for one of my own addresses",
|
|
||||||
"fromVpnAddrs", fromVpnAddrs,
|
|
||||||
"queryVpnAddr", queryVpnAddr,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
found, ln, err := lhh.lh.queryAndPrepMessage(queryVpnAddr, func(c *cache) (int, error) {
|
found, ln, err := lhh.lh.queryAndPrepMessage(queryVpnAddr, func(c *cache) (int, error) {
|
||||||
n = lhh.resetMeta()
|
n = lhh.resetMeta()
|
||||||
n.Type = NebulaMeta_HostQueryReply
|
n.Type = NebulaMeta_HostQueryReply
|
||||||
@@ -1255,13 +1194,10 @@ func (lhh *LightHouseHandler) handleHostQuery(n *NebulaMeta, fromVpnAddrs []neti
|
|||||||
// sendHostPunchNotification signals the other side to punch some zero byte udp packets
|
// sendHostPunchNotification signals the other side to punch some zero byte udp packets
|
||||||
func (lhh *LightHouseHandler) sendHostPunchNotification(n *NebulaMeta, fromVpnAddrs []netip.Addr, punchNotifDest netip.Addr, w EncWriter) {
|
func (lhh *LightHouseHandler) sendHostPunchNotification(n *NebulaMeta, fromVpnAddrs []netip.Addr, punchNotifDest netip.Addr, w EncWriter) {
|
||||||
whereToPunch := fromVpnAddrs[0]
|
whereToPunch := fromVpnAddrs[0]
|
||||||
// Resolve the target before taking the querier's RemoteList lock below. GetHostInfo takes the
|
|
||||||
// hostmap lock, and the hostmap is taken before the lighthouse, which is taken before a
|
|
||||||
// RemoteList, so looking it up inside the callback would deadlock.
|
|
||||||
targetHI := lhh.lh.ifce.GetHostInfo(punchNotifDest)
|
|
||||||
found, ln, err := lhh.lh.queryAndPrepMessage(whereToPunch, func(c *cache) (int, error) {
|
found, ln, err := lhh.lh.queryAndPrepMessage(whereToPunch, func(c *cache) (int, error) {
|
||||||
n = lhh.resetMeta()
|
n = lhh.resetMeta()
|
||||||
n.Type = NebulaMeta_HostPunchNotification
|
n.Type = NebulaMeta_HostPunchNotification
|
||||||
|
targetHI := lhh.lh.ifce.GetHostInfo(punchNotifDest)
|
||||||
var useVersion cert.Version
|
var useVersion cert.Version
|
||||||
if targetHI == nil {
|
if targetHI == nil {
|
||||||
useVersion = lhh.lh.ifce.GetCertState().initiatingVersion
|
useVersion = lhh.lh.ifce.GetCertState().initiatingVersion
|
||||||
|
|||||||
+54
-313
@@ -1,21 +1,16 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
"errors"
|
|
||||||
"fmt"
|
"fmt"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"sync"
|
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/gaissmai/bart"
|
"github.com/gaissmai/bart"
|
||||||
"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/test"
|
"github.com/slackhq/nebula/test"
|
||||||
"github.com/slackhq/nebula/udp"
|
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
"go.yaml.in/yaml/v3"
|
"go.yaml.in/yaml/v3"
|
||||||
@@ -32,27 +27,15 @@ func TestOldIPv4Only(t *testing.T) {
|
|||||||
assert.Equal(t, binary.BigEndian.Uint32(bp[:]), m.GetAddr())
|
assert.Equal(t, binary.BigEndian.Uint32(bp[:]), m.GetAddr())
|
||||||
}
|
}
|
||||||
|
|
||||||
func testCertState(networks ...netip.Prefix) *CertState {
|
|
||||||
cs := &CertState{
|
|
||||||
myVpnNetworks: networks,
|
|
||||||
myVpnNetworksTable: new(bart.Lite),
|
|
||||||
myVpnAddrs: make([]netip.Addr, 0, len(networks)),
|
|
||||||
myVpnAddrsTable: new(bart.Lite),
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, n := range networks {
|
|
||||||
cs.myVpnNetworksTable.Insert(n)
|
|
||||||
cs.myVpnAddrs = append(cs.myVpnAddrs, n.Addr())
|
|
||||||
cs.myVpnAddrsTable.Insert(netip.PrefixFrom(n.Addr(), n.Addr().BitLen()))
|
|
||||||
}
|
|
||||||
|
|
||||||
return cs
|
|
||||||
}
|
|
||||||
|
|
||||||
func Test_lhStaticMapping(t *testing.T) {
|
func Test_lhStaticMapping(t *testing.T) {
|
||||||
l := test.NewLogger()
|
l := test.NewLogger()
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/16")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/16")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
lh1 := "10.128.0.2"
|
lh1 := "10.128.0.2"
|
||||||
|
|
||||||
c := config.NewC(l)
|
c := config.NewC(l)
|
||||||
@@ -72,7 +55,12 @@ func Test_lhStaticMapping(t *testing.T) {
|
|||||||
func TestReloadLighthouseInterval(t *testing.T) {
|
func TestReloadLighthouseInterval(t *testing.T) {
|
||||||
l := test.NewLogger()
|
l := test.NewLogger()
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/16")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/16")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
lh1 := "10.128.0.2"
|
lh1 := "10.128.0.2"
|
||||||
|
|
||||||
c := config.NewC(l)
|
c := config.NewC(l)
|
||||||
@@ -102,7 +90,12 @@ func TestReloadLighthouseInterval(t *testing.T) {
|
|||||||
func BenchmarkLighthouseHandleRequest(b *testing.B) {
|
func BenchmarkLighthouseHandleRequest(b *testing.B) {
|
||||||
l := test.NewLogger()
|
l := test.NewLogger()
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/0")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/0")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
|
|
||||||
c := config.NewC(l)
|
c := config.NewC(l)
|
||||||
lh, err := NewLightHouseFromConfig(b.Context(), l, c, cs, nil, nil)
|
lh, err := NewLightHouseFromConfig(b.Context(), l, c, cs, nil, nil)
|
||||||
@@ -202,7 +195,12 @@ func TestLighthouse_Memory(t *testing.T) {
|
|||||||
c.Settings["listen"] = map[string]any{"port": 4242}
|
c.Settings["listen"] = map[string]any{"port": 4242}
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
||||||
lh.ifce = &mockEncWriter{}
|
lh.ifce = &mockEncWriter{}
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
@@ -282,7 +280,12 @@ func TestLighthouse_reload(t *testing.T) {
|
|||||||
c.Settings["listen"] = map[string]any{"port": 4242}
|
c.Settings["listen"] = map[string]any{"port": 4242}
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
|
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
@@ -312,7 +315,12 @@ func TestLighthouse_reloadStaticHostMap(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
|
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
@@ -421,9 +429,7 @@ func TestLighthouse_reloadStaticHostMap(t *testing.T) {
|
|||||||
assert.Equal(t, []netip.AddrPort{netip.MustParseAddrPort("3.3.3.3:4242")}, rl.CopyAddrs([]netip.Prefix{}))
|
assert.Equal(t, []netip.AddrPort{netip.MustParseAddrPort("3.3.3.3:4242")}, rl.CopyAddrs([]netip.Prefix{}))
|
||||||
}
|
}
|
||||||
|
|
||||||
// sendLHHostRequest delivers a HostQuery to lhh and hands back the writer that
|
func newLHHostRequest(fromAddr netip.AddrPort, myVpnIp, queryVpnIp netip.Addr, lhh *LightHouseHandler) testLhReply {
|
||||||
// captured what it emitted. Pass a nil filter to see every message.
|
|
||||||
func sendLHHostRequest(fromAddr netip.AddrPort, myVpnIp, queryVpnIp netip.Addr, lhh *LightHouseHandler, filter *NebulaMeta_MessageType) *testEncWriter {
|
|
||||||
req := &NebulaMeta{
|
req := &NebulaMeta{
|
||||||
Type: NebulaMeta_HostQuery,
|
Type: NebulaMeta_HostQuery,
|
||||||
Details: &NebulaMetaDetails{},
|
Details: &NebulaMetaDetails{},
|
||||||
@@ -441,59 +447,12 @@ func sendLHHostRequest(fromAddr netip.AddrPort, myVpnIp, queryVpnIp netip.Addr,
|
|||||||
panic(err)
|
panic(err)
|
||||||
}
|
}
|
||||||
|
|
||||||
w := &testEncWriter{metaFilter: filter}
|
|
||||||
lhh.HandleRequest(fromAddr, []netip.Addr{myVpnIp}, b, w)
|
|
||||||
return w
|
|
||||||
}
|
|
||||||
|
|
||||||
func newLHHostRequest(fromAddr netip.AddrPort, myVpnIp, queryVpnIp netip.Addr, lhh *LightHouseHandler) testLhReply {
|
|
||||||
filter := NebulaMeta_HostQueryReply
|
filter := NebulaMeta_HostQueryReply
|
||||||
return sendLHHostRequest(fromAddr, myVpnIp, queryVpnIp, lhh, &filter).lastReply
|
w := &testEncWriter{
|
||||||
|
metaFilter: &filter,
|
||||||
}
|
}
|
||||||
|
lhh.HandleRequest(fromAddr, []netip.Addr{myVpnIp}, b, w)
|
||||||
func TestLighthouse_IgnoresHostQueryForItself(t *testing.T) {
|
return w.lastReply
|
||||||
// Validate that we don't answer host queries for our own address.
|
|
||||||
l := test.NewLogger()
|
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
|
||||||
myVpnIp := myVpnNet.Addr()
|
|
||||||
|
|
||||||
c := config.NewC(l)
|
|
||||||
c.Settings["lighthouse"] = map[string]any{"am_lighthouse": true}
|
|
||||||
c.Settings["listen"] = map[string]any{"port": 4242}
|
|
||||||
// Add a static_host_map entry for ourselves, so our address
|
|
||||||
// is in the addrMap.
|
|
||||||
c.Settings["static_host_map"] = map[string]any{
|
|
||||||
myVpnIp.String(): []any{"192.168.100.1:4242"},
|
|
||||||
}
|
|
||||||
|
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, testCertState(myVpnNet), nil, nil)
|
|
||||||
require.NoError(t, err)
|
|
||||||
lh.ifce = &mockEncWriter{}
|
|
||||||
lhh := lh.NewRequestHandler()
|
|
||||||
|
|
||||||
peerVpnIp := netip.MustParseAddr("10.128.0.2")
|
|
||||||
peerUdpAddr := netip.MustParseAddrPort("10.0.0.2:4242")
|
|
||||||
otherVpnIp := netip.MustParseAddr("10.128.0.3")
|
|
||||||
otherUdpAddr := netip.MustParseAddrPort("10.0.0.3:4242")
|
|
||||||
|
|
||||||
newLHHostUpdate(peerUdpAddr, peerVpnIp, []netip.AddrPort{peerUdpAddr}, lhh)
|
|
||||||
newLHHostUpdate(otherUdpAddr, otherVpnIp, []netip.AddrPort{otherUdpAddr}, lhh)
|
|
||||||
|
|
||||||
// Control: a query about a real peer is still answered, and still ends with
|
|
||||||
// the punch notification aimed at the host that was asked about.
|
|
||||||
w := sendLHHostRequest(peerUdpAddr, peerVpnIp, otherVpnIp, lhh, nil)
|
|
||||||
require.NotNil(t, w.lastReply.msg)
|
|
||||||
assert.Equal(t, NebulaMeta_HostPunchNotification, w.lastReply.msg.Type)
|
|
||||||
assert.Equal(t, otherVpnIp, w.lastReply.vpnIp)
|
|
||||||
|
|
||||||
// Now validate that we don't send to ourselves.
|
|
||||||
found, _, err := lh.queryAndPrepMessage(myVpnIp, func(*cache) (int, error) { return 0, nil })
|
|
||||||
require.NoError(t, err)
|
|
||||||
require.True(t, found, "the lighthouse should hold a cache entry for its own address")
|
|
||||||
|
|
||||||
w = sendLHHostRequest(peerUdpAddr, peerVpnIp, myVpnIp, lhh, nil)
|
|
||||||
assert.Nil(t, w.lastReply.msg, "a query about our own address must produce no reply and no punch notification")
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func newLHHostUpdate(fromAddr netip.AddrPort, vpnIp netip.Addr, addrs []netip.AddrPort, lhh *LightHouseHandler) {
|
func newLHHostUpdate(fromAddr netip.AddrPort, vpnIp netip.Addr, addrs []netip.AddrPort, lhh *LightHouseHandler) {
|
||||||
@@ -539,7 +498,7 @@ type testEncWriter struct {
|
|||||||
protocolVersion cert.Version
|
protocolVersion cert.Version
|
||||||
}
|
}
|
||||||
|
|
||||||
func (tw *testEncWriter) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool, q int) {
|
func (tw *testEncWriter) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool) {
|
||||||
}
|
}
|
||||||
func (tw *testEncWriter) Handshake(vpnIp netip.Addr) {
|
func (tw *testEncWriter) Handshake(vpnIp netip.Addr) {
|
||||||
}
|
}
|
||||||
@@ -683,7 +642,12 @@ func TestLighthouse_Dont_Delete_Static_Hosts(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
lh.ifce = &mockEncWriter{}
|
lh.ifce = &mockEncWriter{}
|
||||||
@@ -744,7 +708,12 @@ func TestLighthouse_DeletesWork(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
||||||
cs := testCertState(myVpnNet)
|
nt := new(bart.Lite)
|
||||||
|
nt.Insert(myVpnNet)
|
||||||
|
cs := &CertState{
|
||||||
|
myVpnNetworks: []netip.Prefix{myVpnNet},
|
||||||
|
myVpnNetworksTable: nt,
|
||||||
|
}
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
lh.ifce = &mockEncWriter{}
|
lh.ifce = &mockEncWriter{}
|
||||||
@@ -769,231 +738,3 @@ func TestLighthouse_DeletesWork(t *testing.T) {
|
|||||||
out = lh.Query(testHost)
|
out = lh.Query(testHost)
|
||||||
assert.Nil(t, out)
|
assert.Nil(t, out)
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestLightHouse_logLocalAddrsErr(t *testing.T) {
|
|
||||||
out := &bytes.Buffer{}
|
|
||||||
lh := &LightHouse{l: test.NewLoggerWithOutput(out)}
|
|
||||||
|
|
||||||
// The first sighting of a failure warns.
|
|
||||||
lh.logLocalAddrsErr(errors.New("permission denied"))
|
|
||||||
assert.Contains(t, out.String(), "level=WARN")
|
|
||||||
assert.Contains(t, out.String(), "permission denied")
|
|
||||||
|
|
||||||
// Repeating unchanged does not warn again, which is what keeps a permanent failure from warning
|
|
||||||
// on every lighthouse.interval for the life of the process.
|
|
||||||
out.Reset()
|
|
||||||
lh.logLocalAddrsErr(errors.New("permission denied"))
|
|
||||||
assert.NotContains(t, out.String(), "level=WARN")
|
|
||||||
|
|
||||||
// A different failure is a new event and warns.
|
|
||||||
out.Reset()
|
|
||||||
lh.logLocalAddrsErr(errors.New("something else"))
|
|
||||||
assert.Contains(t, out.String(), "level=WARN")
|
|
||||||
assert.Contains(t, out.String(), "something else")
|
|
||||||
|
|
||||||
// Recovering resets, so the same failure returning later warns again.
|
|
||||||
out.Reset()
|
|
||||||
lh.logLocalAddrsErr(nil)
|
|
||||||
assert.Empty(t, out.String())
|
|
||||||
lh.logLocalAddrsErr(errors.New("something else"))
|
|
||||||
assert.Contains(t, out.String(), "level=WARN")
|
|
||||||
}
|
|
||||||
|
|
||||||
// heldEncWriter holds the query worker in its first GetHostInfo until release closes.
|
|
||||||
type heldEncWriter struct {
|
|
||||||
mockEncWriter
|
|
||||||
once sync.Once
|
|
||||||
held chan struct{}
|
|
||||||
release chan struct{}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *heldEncWriter) GetHostInfo(netip.Addr) *HostInfo {
|
|
||||||
w.once.Do(func() { close(w.held) })
|
|
||||||
<-w.release
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// QueryServer never waits on the query worker, since the packet readers call it and nothing drains the channel at
|
|
||||||
// shutdown; a query that finds the channel full is dropped and counted. The worker is held on its first query so the
|
|
||||||
// channel fills.
|
|
||||||
func TestLighthouse_QueryServerDoesNotBlock(t *testing.T) {
|
|
||||||
l := test.NewLogger()
|
|
||||||
cs := testCertState(netip.MustParsePrefix("10.128.0.1/16"))
|
|
||||||
lh1 := "10.128.0.2"
|
|
||||||
c := config.NewC(l)
|
|
||||||
c.Settings["lighthouse"] = map[string]any{"hosts": []any{lh1}}
|
|
||||||
c.Settings["static_host_map"] = map[string]any{lh1: []any{"1.1.1.1:4242"}}
|
|
||||||
c.Settings["handshakes"] = map[string]any{"query_buffer": 1}
|
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
|
|
||||||
require.NoError(t, err)
|
|
||||||
w := &heldEncWriter{held: make(chan struct{}), release: make(chan struct{})}
|
|
||||||
lh.ifce = w
|
|
||||||
t.Cleanup(func() { close(w.release) })
|
|
||||||
|
|
||||||
lh.QueryServer(netip.MustParseAddr("10.128.0.10"))
|
|
||||||
select {
|
|
||||||
case <-w.held:
|
|
||||||
case <-time.After(5 * time.Second):
|
|
||||||
t.Fatal("the query worker never took the first query")
|
|
||||||
}
|
|
||||||
dropped := lh.queryDropped.Count()
|
|
||||||
done := make(chan struct{})
|
|
||||||
go func() {
|
|
||||||
lh.QueryServer(netip.MustParseAddr("10.128.0.11"))
|
|
||||||
lh.QueryServer(netip.MustParseAddr("10.128.0.12"))
|
|
||||||
close(done)
|
|
||||||
}()
|
|
||||||
select {
|
|
||||||
case <-done:
|
|
||||||
case <-time.After(5 * time.Second):
|
|
||||||
t.Fatal("QueryServer blocked on a full query channel")
|
|
||||||
}
|
|
||||||
assert.EqualValues(t, 1, lh.queryDropped.Count()-dropped)
|
|
||||||
}
|
|
||||||
|
|
||||||
// hostmapEncWriter answers GetHostInfo from a real hostmap, the way Interface does.
|
|
||||||
type hostmapEncWriter struct {
|
|
||||||
mockEncWriter
|
|
||||||
hm *HostMap
|
|
||||||
}
|
|
||||||
|
|
||||||
func (w *hostmapEncWriter) GetHostInfo(a netip.Addr) *HostInfo { return w.hm.QueryVpnAddr(a) }
|
|
||||||
func (w *hostmapEncWriter) GetCertState() *CertState {
|
|
||||||
return &CertState{initiatingVersion: cert.Version1}
|
|
||||||
}
|
|
||||||
|
|
||||||
// A lighthouse runs four paths that each hold one lock while waiting for the next: CheckAndComplete
|
|
||||||
// holds the hostmap and takes the handshake manager, StartHandshake holds the handshake manager and
|
|
||||||
// takes the lighthouse, a host update holds the lighthouse and takes the sender's RemoteList, and a
|
|
||||||
// punch notification holds the querier's RemoteList while it resolves the target. If that last step
|
|
||||||
// reaches the hostmap under the RemoteList lock, the four deadlock. Drive them all at once.
|
|
||||||
func TestLighthouse_PunchNotificationDoesNotCloseLockCycle(t *testing.T) {
|
|
||||||
l := test.NewLogger()
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
|
||||||
|
|
||||||
c := config.NewC(l)
|
|
||||||
c.Settings["lighthouse"] = map[string]any{"am_lighthouse": true}
|
|
||||||
c.Settings["listen"] = map[string]any{"port": 4242}
|
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, testCertState(myVpnNet), nil, nil)
|
|
||||||
require.NoError(t, err)
|
|
||||||
|
|
||||||
mainHM := newHostMap(l)
|
|
||||||
pr := []netip.Prefix{}
|
|
||||||
mainHM.preferredRanges.Store(&pr)
|
|
||||||
lh.ifce = &hostmapEncWriter{hm: mainHM}
|
|
||||||
|
|
||||||
hm := NewHandshakeManager(l, mainHM, lh, &udp.NoopConn{}, defaultHandshakeConfig)
|
|
||||||
f := &Interface{hostMap: mainHM, lightHouse: lh, handshakeManager: hm, l: l}
|
|
||||||
hm.f = f
|
|
||||||
|
|
||||||
peer := netip.MustParseAddr("10.128.0.2")
|
|
||||||
peerUdp := netip.MustParseAddrPort("10.0.0.2:4242")
|
|
||||||
target := netip.MustParseAddr("10.128.0.3")
|
|
||||||
targetUdp := netip.MustParseAddrPort("10.0.0.3:4242")
|
|
||||||
outbound := netip.MustParseAddr("10.128.0.4")
|
|
||||||
inbound := netip.MustParseAddr("10.128.0.5")
|
|
||||||
|
|
||||||
seed := lh.NewRequestHandler()
|
|
||||||
newLHHostUpdate(peerUdp, peer, []netip.AddrPort{peerUdp}, seed)
|
|
||||||
newLHHostUpdate(targetUdp, target, []netip.AddrPort{targetUdp}, seed)
|
|
||||||
|
|
||||||
stop := make(chan struct{})
|
|
||||||
var wg sync.WaitGroup
|
|
||||||
loop := func(body func()) {
|
|
||||||
defer wg.Done()
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case <-stop:
|
|
||||||
return
|
|
||||||
default:
|
|
||||||
body()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
wg.Add(4)
|
|
||||||
|
|
||||||
// Outbound handshakes keep starting and being dropped.
|
|
||||||
go loop(func() {
|
|
||||||
hm.DeleteHostInfo(hm.StartHandshake(outbound, nil))
|
|
||||||
})
|
|
||||||
|
|
||||||
// Inbound handshakes keep completing and being torn down.
|
|
||||||
var idx uint32
|
|
||||||
go loop(func() {
|
|
||||||
idx++
|
|
||||||
hi := &HostInfo{
|
|
||||||
vpnAddrs: []netip.Addr{inbound},
|
|
||||||
localIndexId: idx,
|
|
||||||
remoteIndexId: idx,
|
|
||||||
remotes: lh.QueryCache([]netip.Addr{inbound}),
|
|
||||||
HandshakePacket: map[uint8][]byte{handshakePacketStage0: {byte(idx)}},
|
|
||||||
}
|
|
||||||
if _, err := hm.CheckAndComplete(hi, handshakePacketStage0, f); err == nil {
|
|
||||||
mainHM.DeleteHostInfo(hi)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
// The peer keeps sending host updates.
|
|
||||||
updates := lh.NewRequestHandler()
|
|
||||||
go loop(func() {
|
|
||||||
newLHHostUpdate(peerUdp, peer, []netip.AddrPort{peerUdp}, updates)
|
|
||||||
})
|
|
||||||
|
|
||||||
// The same peer keeps querying for the target, which ends in a punch notification.
|
|
||||||
queries := lh.NewRequestHandler()
|
|
||||||
go loop(func() {
|
|
||||||
sendLHHostRequest(peerUdp, peer, target, queries, nil)
|
|
||||||
})
|
|
||||||
|
|
||||||
time.Sleep(time.Second)
|
|
||||||
close(stop)
|
|
||||||
done := make(chan struct{})
|
|
||||||
go func() { wg.Wait(); close(done) }()
|
|
||||||
select {
|
|
||||||
case <-done:
|
|
||||||
case <-time.After(5 * time.Second):
|
|
||||||
t.Fatal("deadlock: the lighthouse paths never finished after stop was signalled")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestLighthouse_reloadRelaysTriggersUpdate(t *testing.T) {
|
|
||||||
l := test.NewLogger()
|
|
||||||
c := config.NewC(l)
|
|
||||||
base := "lighthouse:\n am_lighthouse: true\nlisten:\n port: 4242\n"
|
|
||||||
require.NoError(t, c.LoadString(base+"relay:\n relays: [10.128.0.5]\n"))
|
|
||||||
|
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, testCertState(netip.MustParsePrefix("10.128.0.1/24")), nil, nil)
|
|
||||||
require.NoError(t, err)
|
|
||||||
assert.Empty(t, lh.updateTrigger)
|
|
||||||
|
|
||||||
require.NoError(t, c.ReloadConfigString(base+"relay:\n relays: [10.128.0.6]\n"))
|
|
||||||
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.6")}, lh.GetRelaysForMe())
|
|
||||||
require.Len(t, lh.updateTrigger, 1)
|
|
||||||
<-lh.updateTrigger
|
|
||||||
|
|
||||||
// The config changed but what we advertise did not, a bad entry is skipped
|
|
||||||
require.NoError(t, c.ReloadConfigString(base+"relay:\n relays: [10.128.0.6, nope]\n"))
|
|
||||||
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.6")}, lh.GetRelaysForMe())
|
|
||||||
assert.Empty(t, lh.updateTrigger)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestLighthouse_reloadAmRelayAlone(t *testing.T) {
|
|
||||||
l := test.NewLogger()
|
|
||||||
c := config.NewC(l)
|
|
||||||
base := "lighthouse:\n am_lighthouse: true\nlisten:\n port: 4242\nrelay:\n relays: [10.128.0.5]\n"
|
|
||||||
require.NoError(t, c.LoadString(base+" am_relay: false\n"))
|
|
||||||
|
|
||||||
lh, err := NewLightHouseFromConfig(t.Context(), l, c, testCertState(netip.MustParsePrefix("10.128.0.1/24")), nil, nil)
|
|
||||||
require.NoError(t, err)
|
|
||||||
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.5")}, lh.GetRelaysForMe())
|
|
||||||
|
|
||||||
// Relays aren't allowed to have relays, flipping am_relay alone must drop them and tell the lighthouses
|
|
||||||
require.NoError(t, c.ReloadConfigString(base+" am_relay: true\n"))
|
|
||||||
assert.Empty(t, lh.GetRelaysForMe())
|
|
||||||
require.Len(t, lh.updateTrigger, 1)
|
|
||||||
<-lh.updateTrigger
|
|
||||||
|
|
||||||
require.NoError(t, c.ReloadConfigString(base+" am_relay: false\n"))
|
|
||||||
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.5")}, lh.GetRelaysForMe())
|
|
||||||
require.Len(t, lh.updateTrigger, 1)
|
|
||||||
}
|
|
||||||
@@ -1,31 +0,0 @@
|
|||||||
package logging
|
|
||||||
|
|
||||||
import "log/slog"
|
|
||||||
|
|
||||||
// RateLimiter is what RateLimited needs from a rate limiter, such as a *ratelimit.Limiter.
|
|
||||||
// Allow reports whether this call may proceed, and how many calls were denied since the last one that did.
|
|
||||||
type RateLimiter interface {
|
|
||||||
Allow() (denied uint64, ok bool)
|
|
||||||
}
|
|
||||||
|
|
||||||
// RateLimited checks lim before anything is built.
|
|
||||||
// When allowed it returns l, with a "suppressed" count attached if lim denied calls since its last allowed one.
|
|
||||||
// A nil lim allows everything.
|
|
||||||
//
|
|
||||||
// if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok {
|
|
||||||
// hostinfo.logger(l).Error("Failed to write outgoing packet", "error", err)
|
|
||||||
// }
|
|
||||||
func RateLimited(l *slog.Logger, lim RateLimiter) (*slog.Logger, bool) {
|
|
||||||
if lim == nil {
|
|
||||||
return l, true
|
|
||||||
}
|
|
||||||
|
|
||||||
denied, ok := lim.Allow()
|
|
||||||
if !ok {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
if denied > 0 {
|
|
||||||
return l.With("suppressed", denied), true
|
|
||||||
}
|
|
||||||
return l, true
|
|
||||||
}
|
|
||||||
@@ -1,106 +0,0 @@
|
|||||||
package logging
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"errors"
|
|
||||||
"io"
|
|
||||||
"log/slog"
|
|
||||||
"net/netip"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/ratelimit"
|
|
||||||
)
|
|
||||||
|
|
||||||
type fakeLimiter struct {
|
|
||||||
denied uint64
|
|
||||||
ok bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f fakeLimiter) Allow() (uint64, bool) { return f.denied, f.ok }
|
|
||||||
|
|
||||||
func TestRateLimited(t *testing.T) {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
base := NewLogger(&buf)
|
|
||||||
|
|
||||||
if l, ok := RateLimited(base, fakeLimiter{ok: false}); ok || l != nil {
|
|
||||||
t.Fatalf("denied call: ok=%v logger=%v", ok, l)
|
|
||||||
}
|
|
||||||
|
|
||||||
if l, ok := RateLimited(base, fakeLimiter{ok: true}); !ok || l != base {
|
|
||||||
t.Fatal("nothing denied should hand back the same logger")
|
|
||||||
}
|
|
||||||
|
|
||||||
if l, ok := RateLimited(base, nil); !ok || l != base {
|
|
||||||
t.Fatal("a nil limiter should allow with the same logger")
|
|
||||||
}
|
|
||||||
|
|
||||||
l, ok := RateLimited(base, fakeLimiter{denied: 7, ok: true})
|
|
||||||
if !ok {
|
|
||||||
t.Fatal("allowed call denied")
|
|
||||||
}
|
|
||||||
l.Info("hello", "k", "v")
|
|
||||||
if !strings.Contains(buf.String(), "suppressed=7") {
|
|
||||||
t.Fatalf("want suppressed=7, got %q", buf.String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// The benchmarks compare a log line through slog directly against the same line behind RateLimited: logged with
|
|
||||||
// nothing denied, denied, and logged after denials.
|
|
||||||
|
|
||||||
var (
|
|
||||||
benchErr = errors.New("sendto: no buffer space available")
|
|
||||||
benchAddr = netip.MustParseAddrPort("192.0.2.1:4242")
|
|
||||||
)
|
|
||||||
|
|
||||||
func benchLogger() *slog.Logger {
|
|
||||||
return NewLogger(io.Discard).With("localIndex", 1234, "remoteIndex", 5678)
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkRateLimitedBaseline(b *testing.B) {
|
|
||||||
lg := benchLogger()
|
|
||||||
b.ReportAllocs()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
lg.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkRateLimitedAllowed(b *testing.B) {
|
|
||||||
lg, lim := benchLogger(), mustLimiter(b, 1, 0)
|
|
||||||
b.ReportAllocs()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
if l, ok := RateLimited(lg, lim); ok {
|
|
||||||
l.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkRateLimitedDenied(b *testing.B) {
|
|
||||||
lg, lim := benchLogger(), mustLimiter(b, 1, time.Hour)
|
|
||||||
lim.Allow()
|
|
||||||
b.ReportAllocs()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
if l, ok := RateLimited(lg, lim); ok {
|
|
||||||
l.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func BenchmarkRateLimitedAfterDenied(b *testing.B) {
|
|
||||||
lg, lim := benchLogger(), fakeLimiter{denied: 5, ok: true}
|
|
||||||
b.ReportAllocs()
|
|
||||||
for i := 0; i < b.N; i++ {
|
|
||||||
if l, ok := RateLimited(lg, lim); ok {
|
|
||||||
l.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func mustLimiter(b *testing.B, burst int, every time.Duration) *ratelimit.Limiter {
|
|
||||||
l, err := ratelimit.New(burst, every)
|
|
||||||
if err != nil {
|
|
||||||
b.Fatal(err)
|
|
||||||
}
|
|
||||||
return l
|
|
||||||
}
|
|
||||||
@@ -6,14 +6,11 @@ import (
|
|||||||
"log/slog"
|
"log/slog"
|
||||||
"net"
|
"net"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"os"
|
|
||||||
"runtime/debug"
|
"runtime/debug"
|
||||||
"slices"
|
|
||||||
"strings"
|
"strings"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/cpupick"
|
|
||||||
"github.com/slackhq/nebula/noiseutil"
|
"github.com/slackhq/nebula/noiseutil"
|
||||||
"github.com/slackhq/nebula/overlay"
|
"github.com/slackhq/nebula/overlay"
|
||||||
"github.com/slackhq/nebula/sshd"
|
"github.com/slackhq/nebula/sshd"
|
||||||
@@ -32,12 +29,9 @@ const _ = noiseutil.RejectHeadroom - 4*maxRoutines
|
|||||||
|
|
||||||
func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, deviceFactory overlay.DeviceFactory) (retcon *Control, reterr error) {
|
func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, deviceFactory overlay.DeviceFactory) (retcon *Control, reterr error) {
|
||||||
ctx, cancel := context.WithCancel(context.Background())
|
ctx, cancel := context.WithCancel(context.Background())
|
||||||
// The goroutines started below stop only when this context does, and only a caller holding the
|
// Automatically cancel the context if Main returns an error, to signal all created goroutines to quit.
|
||||||
// Control can arrange that. Cancel whenever we are not handing one back, which covers an error
|
|
||||||
// and a config test alike: a config test used to leave the lighthouse query worker, and a
|
|
||||||
// hostname resolver per dns named static host, running for the life of the process.
|
|
||||||
defer func() {
|
defer func() {
|
||||||
if retcon == nil {
|
if reterr != nil {
|
||||||
cancel()
|
cancel()
|
||||||
}
|
}
|
||||||
}()
|
}()
|
||||||
@@ -46,9 +40,6 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
buildVersion = moduleVersion()
|
buildVersion = moduleVersion()
|
||||||
}
|
}
|
||||||
|
|
||||||
// Debug builds (-tags debug) serve pprof on :6060; a no-op otherwise.
|
|
||||||
startPprofServer(ctx, l)
|
|
||||||
|
|
||||||
// Print the config if in test, the exit comes later
|
// Print the config if in test, the exit comes later
|
||||||
if configTest {
|
if configTest {
|
||||||
b, err := yaml.Marshal(c.Settings)
|
b, err := yaml.Marshal(c.Settings)
|
||||||
@@ -179,21 +170,8 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
}
|
}
|
||||||
|
|
||||||
for i := 0; i < routines; i++ {
|
for i := 0; i < routines; i++ {
|
||||||
listen := netip.AddrPortFrom(listenHost, uint16(port))
|
l.Info("listening", "addr", netip.AddrPortFrom(listenHost, uint16(port)))
|
||||||
l.Info("listening", "addr", listen)
|
udpServer, err := udp.NewListener(l, listenHost, port, routines > 1, c.GetInt("listen.batch", 64))
|
||||||
batchSize := c.GetInt("listen.batch", 64)
|
|
||||||
if batchSize < 1 {
|
|
||||||
oldBatch := batchSize
|
|
||||||
batchSize = 1
|
|
||||||
l.Warn("listen.batch size is invalid", "provided", oldBatch, "overridden to", batchSize)
|
|
||||||
}
|
|
||||||
udpSettings := udp.Settings{
|
|
||||||
Listen: listen,
|
|
||||||
Multi: routines > 1,
|
|
||||||
Batch: batchSize,
|
|
||||||
Offloads: c.GetBool("listen.udp_offloads", false),
|
|
||||||
}
|
|
||||||
udpServer, err := udp.NewListener(l, udpSettings)
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, util.NewContextualError("Failed to open udp listener", m{"queue": i}, err)
|
return nil, util.NewContextualError("Failed to open udp listener", m{"queue": i}, err)
|
||||||
}
|
}
|
||||||
@@ -242,45 +220,6 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
l.Warn("Failed to start DNS responder", "error", err)
|
l.Warn("Failed to start DNS responder", "error", err)
|
||||||
}
|
}
|
||||||
|
|
||||||
pinThreads := c.GetBool("tun.pin_threads", true)
|
|
||||||
avoidCPUs := parseAvoidCPUs(c, l)
|
|
||||||
if len(avoidCPUs) > 0 && !pinThreads {
|
|
||||||
l.Warn("tun.avoid_cpus has no effect with tun.pin_threads disabled")
|
|
||||||
}
|
|
||||||
// Keeping every thread of the process off avoidCPUs, not just the pinned readers, is parked for now:
|
|
||||||
//if err := cpupick.Avoid(avoidCPUs, !configTest); err != nil && !errors.Is(err, errors.ErrUnsupported) {
|
|
||||||
// return nil, fmt.Errorf("tun.avoid_cpus: %w", err)
|
|
||||||
//}
|
|
||||||
cpuAffinity := parseCpuAffinity(c, l, routines, avoidCPUs)
|
|
||||||
if pinThreads && routines > 1 && len(cpuAffinity) == 0 && !configTest {
|
|
||||||
// The operator didn't choose pin CPUs, so pick a default set that
|
|
||||||
// prefers performance cores, skips tun.avoid_cpus and doesn't stack
|
|
||||||
// co-located instances onto allowed[0].
|
|
||||||
|
|
||||||
// key is used to seed the spreading of routines->cores.
|
|
||||||
// use PID if you want to ensure many different Nebulas in VMs or containers land on different cores
|
|
||||||
// use port if you want to always end up on the same cores, ideal for benchmarking.
|
|
||||||
key := uint64(os.Getpid()) //default to PID
|
|
||||||
pinKeyStr := strings.ToLower(c.GetString("tun.pin_threads_key", ""))
|
|
||||||
switch pinKeyStr {
|
|
||||||
case "":
|
|
||||||
l.Debug("tun.pin_threads_key is empty, using PID")
|
|
||||||
case "pid":
|
|
||||||
l.Debug("tun.pin_threads_key is PID")
|
|
||||||
case "port":
|
|
||||||
if ap, err := udpConns[0].LocalAddr(); err == nil && ap.Port() != 0 {
|
|
||||||
l.Info("tun.pin_threads_key is port number")
|
|
||||||
key = uint64(ap.Port())
|
|
||||||
} else {
|
|
||||||
l.Warn("Failed to get a port number for tun.pin_threads_key, falling back to PID", "err", err)
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
l.Warn("tun.pin_threads_key is invalid, using PID")
|
|
||||||
}
|
|
||||||
|
|
||||||
cpuAffinity = cpupick.Default(routines, key, avoidCPUs, l)
|
|
||||||
}
|
|
||||||
|
|
||||||
ifConfig := &InterfaceConfig{
|
ifConfig := &InterfaceConfig{
|
||||||
HostMap: hostMap,
|
HostMap: hostMap,
|
||||||
Inside: tun,
|
Inside: tun,
|
||||||
@@ -302,14 +241,10 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
relayManager: NewRelayManager(ctx, l, hostMap, c),
|
relayManager: NewRelayManager(ctx, l, hostMap, c),
|
||||||
punchy: punchy,
|
punchy: punchy,
|
||||||
ConntrackCacheTimeout: conntrackCacheTimeout,
|
ConntrackCacheTimeout: conntrackCacheTimeout,
|
||||||
CpuAffinity: cpuAffinity,
|
|
||||||
AvoidCPUs: avoidCPUs,
|
|
||||||
PinThreads: pinThreads,
|
|
||||||
l: l,
|
l: l,
|
||||||
}
|
}
|
||||||
|
|
||||||
var ifce *Interface
|
var ifce *Interface
|
||||||
var emitStats func()
|
|
||||||
if !configTest {
|
if !configTest {
|
||||||
ifce, err = NewInterface(ctx, ifConfig)
|
ifce, err = NewInterface(ctx, ifConfig)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
@@ -328,12 +263,9 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
go handshakeManager.Run(ctx)
|
go handshakeManager.Run(ctx)
|
||||||
|
|
||||||
punchy.Start(ctx, ifce, hostMap, lightHouse)
|
punchy.Start(ctx, ifce, hostMap, lightHouse)
|
||||||
|
|
||||||
// On the stats server's loop, so the gauges follow the interval it accepted
|
|
||||||
emitStats = ifce.statsEmitter()
|
|
||||||
}
|
}
|
||||||
|
|
||||||
stats, err := newStatsServerFromConfig(ctx, l, c, buildVersion, configTest, emitStats)
|
stats, err := newStatsServerFromConfig(ctx, l, c, buildVersion, configTest)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, util.ContextualizeIfNeeded("Failed to start stats emitter", err)
|
return nil, util.ContextualizeIfNeeded("Failed to start stats emitter", err)
|
||||||
}
|
}
|
||||||
@@ -342,6 +274,8 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
return nil, nil
|
return nil, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
go ifce.emitStats(ctx, c.GetDuration("stats.interval", time.Second*10))
|
||||||
|
|
||||||
attachCommands(l, c, ssh, ifce)
|
attachCommands(l, c, ssh, ifce)
|
||||||
|
|
||||||
networkChanges := udp.NewNetworkChangeMonitor(ctx, l, c)
|
networkChanges := udp.NewNetworkChangeMonitor(ctx, l, c)
|
||||||
@@ -361,107 +295,6 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
}, nil
|
}, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// parseCpuAffinity reads `tun.cpu_affinity` from the config — a list of
|
|
||||||
// integer CPU IDs, one per TUN reader goroutine. Empty / unset returns nil
|
|
||||||
// (listenIn falls back to spreading queues across the allowed CPU set).
|
|
||||||
// Length mismatch with `routines` is a warning, not an error: shorter lists
|
|
||||||
// are modulo-cycled across queues, longer lists' tail is ignored. Invalid
|
|
||||||
// entries (non-integer, or a CPU ID we're not allowed to run on) are also a
|
|
||||||
// warning and disable the override entirely so we don't silently pin to the
|
|
||||||
// wrong CPU. Entries are validated against the process's current affinity
|
|
||||||
// mask (util.AllowedCPUs) rather than 0..NumCPU-1: under a cgroup cpuset or
|
|
||||||
// taskset the runnable IDs are frequently not that contiguous range, and
|
|
||||||
// pinning to an unrunnable ID always fails. If the allowed set can't be
|
|
||||||
// determined we fall back to a plain non-negative check. An entry listed in
|
|
||||||
// avoid (tun.avoid_cpus) contradicts the operator's own config and is treated
|
|
||||||
// the same as any other invalid entry.
|
|
||||||
func parseCpuAffinity(c *config.C, l *slog.Logger, routines int, avoid []int) []int {
|
|
||||||
raw := c.Get("tun.cpu_affinity")
|
|
||||||
if raw == nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
rv, ok := raw.([]any)
|
|
||||||
if !ok {
|
|
||||||
l.Warn("tun.cpu_affinity must be a list of integers; ignoring", "value", raw)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
// allowed is the set of CPU IDs we're actually permitted to run on. A nil
|
|
||||||
// slice (unsupported platform or lookup error) means "can't tell", so we
|
|
||||||
// only apply the weaker non-negative check in that case.
|
|
||||||
allowed, err := util.AllowedCPUs()
|
|
||||||
if err != nil {
|
|
||||||
l.Warn("could not determine allowed CPUs; validating tun.cpu_affinity against non-negative only", "error", err)
|
|
||||||
allowed = nil
|
|
||||||
}
|
|
||||||
cpus := make([]int, 0, len(rv))
|
|
||||||
for i, e := range rv {
|
|
||||||
var cpu int
|
|
||||||
switch v := e.(type) {
|
|
||||||
case int:
|
|
||||||
cpu = v
|
|
||||||
case int64:
|
|
||||||
cpu = int(v)
|
|
||||||
case float64:
|
|
||||||
cpu = int(v)
|
|
||||||
default:
|
|
||||||
l.Warn("tun.cpu_affinity entry not an integer; ignoring affinity",
|
|
||||||
"index", i, "value", e)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
if cpu < 0 {
|
|
||||||
l.Warn("tun.cpu_affinity entry out of range; ignoring affinity",
|
|
||||||
"index", i, "cpu", cpu)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
if len(allowed) > 0 && !slices.Contains(allowed, cpu) {
|
|
||||||
l.Warn("tun.cpu_affinity entry not in allowed CPU set; ignoring affinity",
|
|
||||||
"index", i, "cpu", cpu, "allowed", allowed)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
if slices.Contains(avoid, cpu) {
|
|
||||||
l.Warn("tun.cpu_affinity entry is listed in tun.avoid_cpus; ignoring affinity",
|
|
||||||
"index", i, "cpu", cpu)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
cpus = append(cpus, cpu)
|
|
||||||
}
|
|
||||||
if len(cpus) != routines {
|
|
||||||
l.Warn("tun.cpu_affinity length doesn't match routines; queues will modulo-cycle through the list",
|
|
||||||
"affinity_len", len(cpus), "routines", routines)
|
|
||||||
}
|
|
||||||
return cpus
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseAvoidCPUs reads tun.avoid_cpus, a list of CPU IDs the tun readers must not be pinned to. IDs outside the
|
|
||||||
// allowed set are accepted, since one config may serve differently shaped hosts. Like tun.cpu_affinity, an invalid
|
|
||||||
// list is a warning and is ignored entirely, as is one covering every allowed CPU, which would leave nowhere to pin.
|
|
||||||
func parseAvoidCPUs(c *config.C, l *slog.Logger) []int {
|
|
||||||
raw := c.Get("tun.avoid_cpus")
|
|
||||||
if raw == nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
values, ok := raw.([]any)
|
|
||||||
if !ok {
|
|
||||||
l.Warn("tun.avoid_cpus must be a list of integers; ignoring", "value", raw)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
cpus := make([]int, 0, len(values))
|
|
||||||
for i, value := range values {
|
|
||||||
cpu, ok := value.(int)
|
|
||||||
if !ok || cpu < 0 {
|
|
||||||
l.Warn("tun.avoid_cpus entry not a non-negative integer; ignoring avoid_cpus", "index", i, "value", value)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
cpus = append(cpus, cpu)
|
|
||||||
}
|
|
||||||
if allowed, err := util.AllowedCPUs(); err == nil && len(allowed) > 0 &&
|
|
||||||
!slices.ContainsFunc(allowed, func(cpu int) bool { return !slices.Contains(cpus, cpu) }) {
|
|
||||||
l.Warn("tun.avoid_cpus covers every allowed CPU; ignoring avoid_cpus", "cpus", cpus, "allowed", allowed)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return cpus
|
|
||||||
}
|
|
||||||
|
|
||||||
func moduleVersion() string {
|
func moduleVersion() string {
|
||||||
info, ok := debug.ReadBuildInfo()
|
info, ok := debug.ReadBuildInfo()
|
||||||
if !ok {
|
if !ok {
|
||||||
|
|||||||
-156
@@ -1,156 +0,0 @@
|
|||||||
package nebula
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"net/netip"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/cert"
|
|
||||||
cert_test "github.com/slackhq/nebula/cert_test"
|
|
||||||
"github.com/slackhq/nebula/config"
|
|
||||||
"github.com/slackhq/nebula/test"
|
|
||||||
"github.com/slackhq/nebula/util"
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
"go.uber.org/goleak"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestParseCpuAffinity(t *testing.T) {
|
|
||||||
l := test.NewLogger()
|
|
||||||
|
|
||||||
// newConfig returns a config.C with tun.cpu_affinity set to v. A nil v
|
|
||||||
// leaves the key unset.
|
|
||||||
newConfig := func(v any) *config.C {
|
|
||||||
c := config.NewC(l)
|
|
||||||
if v != nil {
|
|
||||||
c.Settings["tun"] = map[string]any{"cpu_affinity": v}
|
|
||||||
}
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
|
|
||||||
// unset -> nil (listenIn falls back to spreading across the allowed set)
|
|
||||||
assert.Nil(t, parseCpuAffinity(newConfig(nil), l, 1, nil))
|
|
||||||
|
|
||||||
// Pick a CPU we're actually allowed to run on so a valid list survives
|
|
||||||
// validation regardless of the host's affinity mask.
|
|
||||||
allowed, _ := util.AllowedCPUs()
|
|
||||||
validCPU := 0
|
|
||||||
if len(allowed) > 0 {
|
|
||||||
validCPU = allowed[0]
|
|
||||||
}
|
|
||||||
|
|
||||||
// valid list -> parsed through unchanged
|
|
||||||
assert.Equal(t, []int{validCPU, validCPU}, parseCpuAffinity(newConfig([]any{validCPU, validCPU}), l, 2, nil))
|
|
||||||
|
|
||||||
// a negative entry is out of range on every platform -> disables the override
|
|
||||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, -1}), l, 2, nil))
|
|
||||||
|
|
||||||
// a non-integer entry -> disables the override
|
|
||||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, "not-a-cpu"}), l, 2, nil))
|
|
||||||
|
|
||||||
// a CPU id outside the allowed set -> disables the override. Only assertable
|
|
||||||
// where we can enumerate the allowed set (e.g. linux); 1<<20 is far beyond
|
|
||||||
// any representable CPU id so it can never be in the mask.
|
|
||||||
if len(allowed) > 0 {
|
|
||||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{1 << 20}), l, 1, nil))
|
|
||||||
}
|
|
||||||
|
|
||||||
// an entry also listed in tun.avoid_cpus -> disables the override
|
|
||||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU}), l, 1, []int{validCPU}))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseAvoidCPUs(t *testing.T) {
|
|
||||||
l := test.NewLogger()
|
|
||||||
for _, tc := range []struct {
|
|
||||||
value any
|
|
||||||
want []int
|
|
||||||
}{
|
|
||||||
{nil, nil}, {[]any{}, []int{}}, {[]any{1, 1 << 20}, []int{1, 1 << 20}},
|
|
||||||
{"auto", nil}, {"1,2", nil}, {[]any{-1}, nil}, {[]any{1.5}, nil}, {[]any{1, "2"}, nil},
|
|
||||||
} {
|
|
||||||
c := config.NewC(l)
|
|
||||||
if tc.value != nil {
|
|
||||||
c.Settings["tun"] = map[string]any{"avoid_cpus": tc.value}
|
|
||||||
}
|
|
||||||
assert.Equal(t, tc.want, parseAvoidCPUs(c, l), "%v", tc.value)
|
|
||||||
}
|
|
||||||
|
|
||||||
// avoiding every allowed CPU leaves nowhere to pin; only checkable where the allowed set is known
|
|
||||||
if allowed, _ := util.AllowedCPUs(); len(allowed) > 0 {
|
|
||||||
all := make([]any, len(allowed))
|
|
||||||
for i, cpu := range allowed {
|
|
||||||
all[i] = cpu
|
|
||||||
}
|
|
||||||
c := config.NewC(l)
|
|
||||||
c.Settings["tun"] = map[string]any{"avoid_cpus": all}
|
|
||||||
assert.Nil(t, parseAvoidCPUs(c, l))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestMain_ConfigTestReleasesItsGoroutines pins the rule that Main only leaves goroutines running
|
|
||||||
// when it hands back a Control to stop them with.
|
|
||||||
//
|
|
||||||
// A config test gets no Control, so anything it started had nothing to stop it: the lighthouse
|
|
||||||
// query worker, and a hostname resolver per dns named static host, ran for the life of the
|
|
||||||
// process. That matters to every embedder that validates a config in process rather than by
|
|
||||||
// exec'ing, dnclient and the apple clients included, because they do it on each config load and
|
|
||||||
// the leak accumulates.
|
|
||||||
func TestMain_ConfigTestReleasesItsGoroutines(t *testing.T) {
|
|
||||||
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
|
|
||||||
|
|
||||||
l := test.NewLogger()
|
|
||||||
dir := t.TempDir()
|
|
||||||
|
|
||||||
before := time.Now().Add(-time.Hour)
|
|
||||||
after := time.Now().Add(time.Hour)
|
|
||||||
ca, _, caKey, caPEM := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, before, after, nil, nil, nil)
|
|
||||||
networks := []netip.Prefix{netip.MustParsePrefix("10.0.0.1/24")}
|
|
||||||
_, _, keyPEM, certPEM := cert_test.NewTestCert(
|
|
||||||
cert.Version2, cert.Curve_CURVE25519, ca, caKey, "config-test", before, after, networks, nil, nil)
|
|
||||||
|
|
||||||
caPath := filepath.Join(dir, "ca.pem")
|
|
||||||
certPath := filepath.Join(dir, "cert.pem")
|
|
||||||
keyPath := filepath.Join(dir, "key.pem")
|
|
||||||
require.NoError(t, os.WriteFile(caPath, caPEM, 0o600))
|
|
||||||
require.NoError(t, os.WriteFile(certPath, certPEM, 0o600))
|
|
||||||
require.NoError(t, os.WriteFile(keyPath, keyPEM, 0o600))
|
|
||||||
|
|
||||||
// A static host by address, not by name: the query worker is the goroutine under test and a
|
|
||||||
// hostname would drag a real dns lookup into a unit test.
|
|
||||||
configBody := fmt.Sprintf(`
|
|
||||||
pki:
|
|
||||||
ca: %s
|
|
||||||
cert: %s
|
|
||||||
key: %s
|
|
||||||
static_host_map:
|
|
||||||
"10.0.0.2": ["192.0.2.1:4242"]
|
|
||||||
lighthouse:
|
|
||||||
hosts:
|
|
||||||
- "10.0.0.2"
|
|
||||||
listen:
|
|
||||||
host: 127.0.0.1
|
|
||||||
port: 0
|
|
||||||
tun:
|
|
||||||
disabled: true
|
|
||||||
firewall:
|
|
||||||
outbound:
|
|
||||||
- port: any
|
|
||||||
proto: any
|
|
||||||
host: any
|
|
||||||
inbound:
|
|
||||||
- port: any
|
|
||||||
proto: any
|
|
||||||
host: any
|
|
||||||
`, caPath, certPath, keyPath)
|
|
||||||
require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yml"), []byte(configBody), 0o600))
|
|
||||||
|
|
||||||
c := config.NewC(l)
|
|
||||||
require.NoError(t, c.Load(dir))
|
|
||||||
|
|
||||||
ctrl, err := Main(c, true, "config-test", l, nil)
|
|
||||||
require.NoError(t, err)
|
|
||||||
require.Nil(t, ctrl, "a config test hands back nothing to stop, so it must stop itself")
|
|
||||||
}
|
|
||||||
@@ -1,39 +0,0 @@
|
|||||||
//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...)
|
|
||||||
}
|
|
||||||
@@ -1,104 +0,0 @@
|
|||||||
//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
|
|
||||||
}
|
|
||||||
@@ -1,59 +0,0 @@
|
|||||||
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
|
|
||||||
}
|
|
||||||
@@ -1,117 +0,0 @@
|
|||||||
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")
|
|
||||||
}
|
|
||||||
+66
-4
@@ -1,18 +1,80 @@
|
|||||||
//go:build boringcrypto
|
//go:build boringcrypto
|
||||||
|
// +build boringcrypto
|
||||||
|
|
||||||
package noiseutil
|
package noiseutil
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"crypto/boring"
|
"crypto/aes"
|
||||||
|
"crypto/cipher"
|
||||||
|
"encoding/binary"
|
||||||
|
|
||||||
|
// unsafe needed for go:linkname
|
||||||
|
_ "unsafe"
|
||||||
|
|
||||||
"github.com/flynn/noise"
|
"github.com/flynn/noise"
|
||||||
)
|
)
|
||||||
|
|
||||||
var CipherAESGCM noise.CipherFunc = CipherAESGCMFIPS140
|
|
||||||
|
|
||||||
// EncryptLockNeeded indicates if calls to Encrypt need a lock
|
// EncryptLockNeeded indicates if calls to Encrypt need a lock
|
||||||
// This is true for boringcrypto because the Seal function verifies that the
|
// This is true for boringcrypto because the Seal function verifies that the
|
||||||
// nonce is strictly increasing.
|
// nonce is strictly increasing.
|
||||||
const EncryptLockNeeded = true
|
const EncryptLockNeeded = true
|
||||||
|
|
||||||
var boringEnabled = boring.Enabled()
|
// NewGCMTLS is no longer exposed in go1.19+, so we need to link it in
|
||||||
|
// See: https://github.com/golang/go/issues/56326
|
||||||
|
//
|
||||||
|
// NewGCMTLS is the internal method used with boringcrypto that provides a
|
||||||
|
// validated mode of AES-GCM which enforces the nonce is strictly
|
||||||
|
// monotonically increasing. This is the TLS 1.2 specification for nonce
|
||||||
|
// generation (which also matches the method used by the Noise Protocol)
|
||||||
|
//
|
||||||
|
// - https://github.com/golang/go/blob/go1.19/src/crypto/tls/cipher_suites.go#L520-L522
|
||||||
|
// - https://github.com/golang/go/blob/go1.19/src/crypto/internal/boring/aes.go#L235-L237
|
||||||
|
// - https://github.com/golang/go/blob/go1.19/src/crypto/internal/boring/aes.go#L250
|
||||||
|
// - https://github.com/google/boringssl/blob/ae223d6138807a13006342edfeef32e813246b39/include/openssl/aead.h#L379-L381
|
||||||
|
// - https://github.com/google/boringssl/blob/ae223d6138807a13006342edfeef32e813246b39/crypto/fipsmodule/cipher/e_aes.c#L1082-L1093
|
||||||
|
//
|
||||||
|
//go:linkname newGCMTLS crypto/internal/boring.NewGCMTLS
|
||||||
|
func newGCMTLS(c cipher.Block) (cipher.AEAD, error)
|
||||||
|
|
||||||
|
type cipherFn struct {
|
||||||
|
fn func([32]byte) noise.Cipher
|
||||||
|
name string
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c cipherFn) Cipher(k [32]byte) noise.Cipher { return c.fn(k) }
|
||||||
|
func (c cipherFn) CipherName() string { return c.name }
|
||||||
|
|
||||||
|
// CipherAESGCM is the AES256-GCM AEAD cipher (using NewGCMTLS when GoBoring is present)
|
||||||
|
var CipherAESGCM noise.CipherFunc = cipherFn{cipherAESGCMBoring, "AESGCM"}
|
||||||
|
|
||||||
|
func cipherAESGCMBoring(k [32]byte) noise.Cipher {
|
||||||
|
c, err := aes.NewCipher(k[:])
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
gcm, err := newGCMTLS(c)
|
||||||
|
if err != nil {
|
||||||
|
panic(err)
|
||||||
|
}
|
||||||
|
return aeadCipher{
|
||||||
|
gcm,
|
||||||
|
func(n uint64) []byte {
|
||||||
|
var nonce [12]byte
|
||||||
|
binary.BigEndian.PutUint64(nonce[4:], n)
|
||||||
|
return nonce[:]
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
type aeadCipher struct {
|
||||||
|
cipher.AEAD
|
||||||
|
nonce func(uint64) []byte
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c aeadCipher) Encrypt(out []byte, n uint64, ad, plaintext []byte) []byte {
|
||||||
|
return c.Seal(out, c.nonce(n), plaintext, ad)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c aeadCipher) Decrypt(out []byte, n uint64, ad, ciphertext []byte) ([]byte, error) {
|
||||||
|
return c.Open(out, c.nonce(n), ciphertext, ad)
|
||||||
|
}
|
||||||
@@ -1,8 +1,11 @@
|
|||||||
//go:build boringcrypto
|
//go:build boringcrypto
|
||||||
|
// +build boringcrypto
|
||||||
|
|
||||||
package noiseutil
|
package noiseutil
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"crypto/boring"
|
||||||
|
"encoding/hex"
|
||||||
"testing"
|
"testing"
|
||||||
|
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
@@ -11,3 +14,33 @@ import (
|
|||||||
func TestEncryptLockNeeded(t *testing.T) {
|
func TestEncryptLockNeeded(t *testing.T) {
|
||||||
assert.True(t, EncryptLockNeeded)
|
assert.True(t, EncryptLockNeeded)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Ensure NewGCMTLS validates the nonce is non-repeating
|
||||||
|
func TestNewGCMTLS(t *testing.T) {
|
||||||
|
assert.True(t, boring.Enabled())
|
||||||
|
|
||||||
|
// Test Case 16 from GCM Spec:
|
||||||
|
// - (now dead link): http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-spec.pdf
|
||||||
|
// - as listed in boringssl tests: https://github.com/google/boringssl/blob/fips-20220613/crypto/cipher_extra/test/cipher_tests.txt#L412-L418
|
||||||
|
key, _ := hex.DecodeString("feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308")
|
||||||
|
iv, _ := hex.DecodeString("cafebabefacedbaddecaf888")
|
||||||
|
plaintext, _ := hex.DecodeString("d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39")
|
||||||
|
aad, _ := hex.DecodeString("feedfacedeadbeeffeedfacedeadbeefabaddad2")
|
||||||
|
expected, _ := hex.DecodeString("522dc1f099567d07f47f37a32a84427d643a8cdcbfe5c0c97598a2bd2555d1aa8cb08e48590dbb3da7b08b1056828838c5f61e6393ba7a0abcc9f662")
|
||||||
|
expectedTag, _ := hex.DecodeString("76fc6ece0f4e1768cddf8853bb2d551b")
|
||||||
|
|
||||||
|
expected = append(expected, expectedTag...)
|
||||||
|
|
||||||
|
var keyArray [32]byte
|
||||||
|
copy(keyArray[:], key)
|
||||||
|
c := CipherAESGCM.Cipher(keyArray)
|
||||||
|
aead := c.(aeadCipher).AEAD
|
||||||
|
|
||||||
|
dst := aead.Seal([]byte{}, iv, plaintext, aad)
|
||||||
|
assert.Equal(t, expected, dst)
|
||||||
|
|
||||||
|
// We expect this to fail since we are re-encrypting with a repeat IV
|
||||||
|
assert.PanicsWithError(t, "boringcrypto: EVP_AEAD_CTX_seal failed", func() {
|
||||||
|
dst = aead.Seal([]byte{}, iv, plaintext, aad)
|
||||||
|
})
|
||||||
|
}
|
||||||
@@ -40,11 +40,8 @@ type CipherState interface {
|
|||||||
// NewCipherState wraps the post-handshake noise.CipherState in the per-cipher type that matches cipherFunc.
|
// NewCipherState wraps the post-handshake noise.CipherState in the per-cipher type that matches cipherFunc.
|
||||||
// cipherFunc must be the same cipher used to build the noise CipherSuite that produced s.
|
// cipherFunc must be the same cipher used to build the noise CipherSuite that produced s.
|
||||||
func NewCipherState(s *noise.CipherState, cipherFunc noise.CipherFunc) CipherState {
|
func NewCipherState(s *noise.CipherState, cipherFunc noise.CipherFunc) CipherState {
|
||||||
if cs, ok := s.Cipher().(CipherState); ok {
|
|
||||||
return cs
|
|
||||||
}
|
|
||||||
switch cipherFunc.CipherName() {
|
switch cipherFunc.CipherName() {
|
||||||
case noise.CipherAESGCM.CipherName():
|
case CipherAESGCM.CipherName():
|
||||||
return NewCipherStateAESGCM(s)
|
return NewCipherStateAESGCM(s)
|
||||||
case noise.CipherChaChaPoly.CipherName():
|
case noise.CipherChaChaPoly.CipherName():
|
||||||
return NewCipherStateChaChaPoly(s)
|
return NewCipherStateChaChaPoly(s)
|
||||||
|
|||||||
@@ -1,7 +1,6 @@
|
|||||||
package noiseutil
|
package noiseutil
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"crypto/fips140"
|
|
||||||
"math"
|
"math"
|
||||||
"testing"
|
"testing"
|
||||||
|
|
||||||
@@ -12,30 +11,24 @@ import (
|
|||||||
|
|
||||||
func TestCipherStateAESGCMRoundtrip(t *testing.T) {
|
func TestCipherStateAESGCMRoundtrip(t *testing.T) {
|
||||||
enc, dec := buildCipherStates(t, CipherAESGCM)
|
enc, dec := buildCipherStates(t, CipherAESGCM)
|
||||||
roundtrip(t, NewCipherState(enc, CipherAESGCM), NewCipherState(dec, CipherAESGCM))
|
roundtrip(t, NewCipherStateAESGCM(enc), NewCipherStateAESGCM(dec))
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestCipherStateChaChaPolyRoundtrip(t *testing.T) {
|
func TestCipherStateChaChaPolyRoundtrip(t *testing.T) {
|
||||||
enc, dec := buildCipherStates(t, noise.CipherChaChaPoly)
|
enc, dec := buildCipherStates(t, noise.CipherChaChaPoly)
|
||||||
roundtrip(t, NewCipherState(enc, noise.CipherChaChaPoly), NewCipherState(dec, noise.CipherChaChaPoly))
|
roundtrip(t, NewCipherStateChaChaPoly(enc), NewCipherStateChaChaPoly(dec))
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestNewCipherStateDispatch(t *testing.T) {
|
func TestNewCipherStateDispatch(t *testing.T) {
|
||||||
encA, _ := buildCipherStates(t, CipherAESGCM)
|
encA, _ := buildCipherStates(t, CipherAESGCM)
|
||||||
encC, _ := buildCipherStates(t, noise.CipherChaChaPoly)
|
encC, _ := buildCipherStates(t, noise.CipherChaChaPoly)
|
||||||
|
|
||||||
if !boringEnabled && !fips140.Enabled() {
|
|
||||||
assert.IsType(t, &CipherStateAESGCM{}, NewCipherState(encA, CipherAESGCM))
|
assert.IsType(t, &CipherStateAESGCM{}, NewCipherState(encA, CipherAESGCM))
|
||||||
} else {
|
|
||||||
// fips140
|
|
||||||
assert.IsType(t, encA.Cipher(), NewCipherState(encA, CipherAESGCM))
|
|
||||||
}
|
|
||||||
|
|
||||||
assert.IsType(t, &CipherStateChaChaPoly{}, NewCipherState(encC, noise.CipherChaChaPoly))
|
assert.IsType(t, &CipherStateChaChaPoly{}, NewCipherState(encC, noise.CipherChaChaPoly))
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestNewCipherStateUnsupportedPanics(t *testing.T) {
|
func TestNewCipherStateUnsupportedPanics(t *testing.T) {
|
||||||
enc, _ := buildCipherStates(t, noise.CipherChaChaPoly)
|
enc, _ := buildCipherStates(t, CipherAESGCM)
|
||||||
assert.Panics(t, func() {
|
assert.Panics(t, func() {
|
||||||
NewCipherState(enc, fakeCipher{})
|
NewCipherState(enc, fakeCipher{})
|
||||||
})
|
})
|
||||||
@@ -190,48 +183,3 @@ func TestCipherStateNilSafety(t *testing.T) {
|
|||||||
assert.Empty(t, out)
|
assert.Empty(t, out)
|
||||||
assert.Equal(t, 0, cc.Overhead())
|
assert.Equal(t, 0, cc.Overhead())
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestCipherStateAESGCMInPlaceDecrypt(t *testing.T) {
|
|
||||||
enc, dec := buildCipherStates(t, CipherAESGCM)
|
|
||||||
inPlaceDecrypt(t, NewCipherStateAESGCM(enc), NewCipherStateAESGCM(dec))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCipherStateChaChaPolyInPlaceDecrypt(t *testing.T) {
|
|
||||||
enc, dec := buildCipherStates(t, noise.CipherChaChaPoly)
|
|
||||||
inPlaceDecrypt(t, NewCipherStateChaChaPoly(enc), NewCipherStateChaChaPoly(dec))
|
|
||||||
}
|
|
||||||
|
|
||||||
func inPlaceDecrypt(t *testing.T, enc, dec CipherState) {
|
|
||||||
t.Helper()
|
|
||||||
const hdrLen = 16
|
|
||||||
plaintext := []byte("in-place decrypt should replace the ciphertext bytes")
|
|
||||||
nb := make([]byte, 12)
|
|
||||||
|
|
||||||
// packet = [16-byte header | ciphertext+tag], like a nebula Message.
|
|
||||||
packet := make([]byte, hdrLen, hdrLen+len(plaintext)+enc.Overhead())
|
|
||||||
for i := range packet {
|
|
||||||
packet[i] = byte(i)
|
|
||||||
}
|
|
||||||
packet, err := enc.EncryptDanger(packet, packet[:hdrLen], plaintext, 1, nb)
|
|
||||||
require.NoError(t, err)
|
|
||||||
|
|
||||||
// Simulate a GRO row: [packet | next segment]. A failed auth on packet
|
|
||||||
// may zero packet's plaintext region but must not touch the header, the
|
|
||||||
// tag, or the neighboring segment.
|
|
||||||
neighbor := []byte("next coalesced segment, must stay intact")
|
|
||||||
row := append(append([]byte(nil), packet...), neighbor...)
|
|
||||||
tampered := row[:len(packet)]
|
|
||||||
tampered[hdrLen] ^= 0x01
|
|
||||||
_, err = dec.DecryptDanger(tampered[hdrLen:hdrLen], tampered[:hdrLen], tampered[hdrLen:], 1, nb)
|
|
||||||
require.Error(t, err)
|
|
||||||
assert.Equal(t, packet[:hdrLen], tampered[:hdrLen], "failed auth must not touch the header")
|
|
||||||
assert.Equal(t, packet[len(packet)-dec.Overhead():], tampered[len(tampered)-dec.Overhead():],
|
|
||||||
"failed auth must not touch the tag")
|
|
||||||
assert.Equal(t, neighbor, row[len(packet):], "failed auth must not touch the next segment")
|
|
||||||
|
|
||||||
out, err := dec.DecryptDanger(packet[hdrLen:hdrLen], packet[:hdrLen], packet[hdrLen:], 1, nb)
|
|
||||||
require.NoError(t, err)
|
|
||||||
assert.Equal(t, plaintext, out)
|
|
||||||
// The plaintext must be IN the packet buffer, not a fresh allocation.
|
|
||||||
assert.Equal(t, &packet[hdrLen], &out[0], "plaintext must alias the packet buffer")
|
|
||||||
}
|
|
||||||
@@ -1,197 +0,0 @@
|
|||||||
package noiseutil
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"crypto/cipher"
|
|
||||||
"crypto/fips140"
|
|
||||||
"encoding/binary"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"reflect"
|
|
||||||
"runtime"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
// unsafe needed for go:linkname
|
|
||||||
_ "crypto/tls"
|
|
||||||
_ "unsafe"
|
|
||||||
|
|
||||||
"github.com/flynn/noise"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TODO: Use NewGCMWithCounterNonce or NewGCMForQUIC once available:
|
|
||||||
// - https://github.com/golang/go/issues/73110
|
|
||||||
// - https://github.com/golang/go/issues/79219
|
|
||||||
// Using tls.aeadAESGCMTLS13 gives us the TLS 1.3 GCM, which also verifies
|
|
||||||
// that the nonce is strictly increasing. This works for both boringcrypto
|
|
||||||
// and fips140.
|
|
||||||
//
|
|
||||||
//go:linkname aeadAESGCMTLS13 crypto/tls.aeadAESGCMTLS13
|
|
||||||
func aeadAESGCMTLS13(key, noncePrefix []byte) cipher.AEAD
|
|
||||||
|
|
||||||
type cipherFn struct {
|
|
||||||
fn func([32]byte) noise.Cipher
|
|
||||||
name string
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c cipherFn) Cipher(k [32]byte) noise.Cipher { return c.fn(k) }
|
|
||||||
func (c cipherFn) CipherName() string { return c.name }
|
|
||||||
|
|
||||||
// CipherAESGCMFIPS140 is the AES256-GCM AEAD cipher (using tls.aeadAESGCMTLS13, for both boringcrypto and fips140)
|
|
||||||
var CipherAESGCMFIPS140 noise.CipherFunc = cipherFn{cipherAESGCMFIPS140, "AESGCM"}
|
|
||||||
|
|
||||||
// tls.aeadAESGCMTLS13 uses a 4 byte static prefix and an 8 byte XOR mask
|
|
||||||
var emptyNonce = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
|
|
||||||
|
|
||||||
func cipherAESGCMFIPS140(k [32]byte) noise.Cipher {
|
|
||||||
gcm := aeadAESGCMTLS13(k[:], emptyNonce)
|
|
||||||
gcm = extractFIPSAEAD(gcm)
|
|
||||||
return &aeadGCMFIPS140Cipher{
|
|
||||||
AEAD: gcm,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type aeadGCMFIPS140Cipher struct {
|
|
||||||
cipher.AEAD
|
|
||||||
ready bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Extract the internal FIPS GCM implementation from the tls wrapper. The TLS
|
|
||||||
// wrapper is not thread safe around Open, so instead of locking around it we
|
|
||||||
// can grab the internal implementation that is thread safe. This is the FIPS
|
|
||||||
// module implementation: `crypto/internal/fips140/aes/gcm.GCMWithXORCounterNonce`
|
|
||||||
//
|
|
||||||
// - https://github.com/golang/go/blob/go1.26.4/src/crypto/internal/fips140/aes/gcm/gcm_nonces.go#L212-L287
|
|
||||||
//
|
|
||||||
// The wrapper is struct `crypto/tls.xorNonceAEAD` , with field `aead`:
|
|
||||||
//
|
|
||||||
// - https://github.com/golang/go/blob/go1.26.4/src/crypto/tls/cipher_suites.go#L482-L487
|
|
||||||
//
|
|
||||||
// This can be cleaned up once these FIPS implementations are exposed directly:
|
|
||||||
//
|
|
||||||
// - https://github.com/golang/go/issues/73110
|
|
||||||
func extractFIPSAEAD(xorNonceAEAD cipher.AEAD) cipher.AEAD {
|
|
||||||
r := reflect.ValueOf(xorNonceAEAD)
|
|
||||||
v := r.Elem().FieldByName("aead")
|
|
||||||
if !v.IsValid() {
|
|
||||||
// The internal crypto/tls.xorNonceAEAD struct no longer has an `aead`
|
|
||||||
// field. This can only happen on a Go version this code was not built
|
|
||||||
// against; the package init() self-test guards against ever reaching
|
|
||||||
// this at runtime, so this is a defensive fail-fast.
|
|
||||||
panic(fmt.Sprintf("noiseutil: could not extract FIPS AEAD from %T on %s: no `aead` field (incompatible Go version)", xorNonceAEAD, runtime.Version()))
|
|
||||||
}
|
|
||||||
v2 := reflect.NewAt(v.Type(), unsafe.Pointer(v.UnsafeAddr())).Elem()
|
|
||||||
aead, ok := v2.Interface().(cipher.AEAD)
|
|
||||||
if !ok {
|
|
||||||
panic(fmt.Sprintf("noiseutil: extracted FIPS `aead` field is %s, not a cipher.AEAD, on %s (incompatible Go version)", v2.Type(), runtime.Version()))
|
|
||||||
}
|
|
||||||
return aead
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *aeadGCMFIPS140Cipher) init(nonce []byte) {
|
|
||||||
// GCMWithXORCounterNonce expects that the first call to Seal
|
|
||||||
// is with a counter of `0`, this is how it extracts the nonce mask.
|
|
||||||
// We can clean this up in the future when NewGCMWithCounterNonce or
|
|
||||||
// NewGCMForQUIC are available:
|
|
||||||
if !bytes.Equal(emptyNonce, nonce) {
|
|
||||||
c.AEAD.Seal([]byte{}, emptyNonce, []byte{}, []byte{})
|
|
||||||
}
|
|
||||||
c.ready = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *aeadGCMFIPS140Cipher) Seal(dst, nonce, plaintext, additionalData []byte) []byte {
|
|
||||||
if !c.ready {
|
|
||||||
c.init(nonce)
|
|
||||||
}
|
|
||||||
return c.AEAD.Seal(dst, nonce, plaintext, additionalData)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *aeadGCMFIPS140Cipher) Encrypt(out []byte, n uint64, ad, plaintext []byte) []byte {
|
|
||||||
return c.Seal(out, aeadGCMFIPS140CipherNonce(n), plaintext, ad)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *aeadGCMFIPS140Cipher) Decrypt(out []byte, n uint64, ad, ciphertext []byte) ([]byte, error) {
|
|
||||||
return c.Open(out, aeadGCMFIPS140CipherNonce(n), ciphertext, ad)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *aeadGCMFIPS140Cipher) EncryptDanger(out, ad, plaintext []byte, n uint64, nb []byte) ([]byte, error) {
|
|
||||||
if c == nil {
|
|
||||||
return nil, errors.New("no cipher state available to encrypt")
|
|
||||||
}
|
|
||||||
if n >= RejectAfterMessages {
|
|
||||||
return nil, ErrMessageCounterExhausted
|
|
||||||
}
|
|
||||||
binary.BigEndian.PutUint64(nb[4:], n)
|
|
||||||
out = c.Seal(out, nb, plaintext, ad)
|
|
||||||
return out, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *aeadGCMFIPS140Cipher) DecryptDanger(out, ad, ciphertext []byte, n uint64, nb []byte) ([]byte, error) {
|
|
||||||
if c == nil {
|
|
||||||
return []byte{}, nil
|
|
||||||
}
|
|
||||||
binary.BigEndian.PutUint64(nb[4:], n)
|
|
||||||
return c.Open(out, nb, ciphertext, ad)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *aeadGCMFIPS140Cipher) Overhead() int {
|
|
||||||
if c == nil {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
return c.AEAD.Overhead()
|
|
||||||
}
|
|
||||||
|
|
||||||
func aeadGCMFIPS140CipherNonce(n uint64) []byte {
|
|
||||||
// GCMWithXORCounterNonce uses a 4 byte static prefix and an 8 byte nonce
|
|
||||||
var nonce [12]byte
|
|
||||||
binary.BigEndian.PutUint64(nonce[4:], n)
|
|
||||||
return nonce[:]
|
|
||||||
}
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
if boringEnabled || fips140.Enabled() {
|
|
||||||
initSelfTestAESGCMFIPS140()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// validates the go:linkname + reflection extraction and the nonce-reuse
|
|
||||||
// protection at startup. cipherAESGCMFIPS140 relies on unexported
|
|
||||||
// crypto/tls and crypto/internal/fips140 internals; if a future Go version changes
|
|
||||||
// those, this fails fast with a clear message instead of panicking per-handshake
|
|
||||||
// (or, worse, silently losing the strictly-increasing nonce check that is the whole
|
|
||||||
// point of using this cipher).
|
|
||||||
func initSelfTestAESGCMFIPS140() {
|
|
||||||
var key [32]byte
|
|
||||||
c := cipherAESGCMFIPS140(key)
|
|
||||||
|
|
||||||
// Verify the extracted AEAD produces a working encrypt/decrypt roundtrip.
|
|
||||||
plaintext := []byte("nebula fips140 self-test")
|
|
||||||
ad := []byte("ad")
|
|
||||||
ct := c.Encrypt(nil, 1, ad, plaintext)
|
|
||||||
pt, err := c.Decrypt(nil, 1, ad, ct)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Sprintf("noiseutil: FIPS AES-GCM self-test roundtrip failed on %s: %v", runtime.Version(), err))
|
|
||||||
}
|
|
||||||
if !bytes.Equal(pt, plaintext) {
|
|
||||||
panic(fmt.Sprintf("noiseutil: FIPS AES-GCM self-test roundtrip returned wrong plaintext on %s", runtime.Version()))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify the nonce-reuse protection still fires: re-encrypting with the same
|
|
||||||
// counter must panic. This is the defensive check that FIPS-140 requires, so
|
|
||||||
// if the extraction ever silently yields an AEAD without it, refuse to start.
|
|
||||||
if !reusePanics(c) {
|
|
||||||
panic(fmt.Sprintf("noiseutil: FIPS AES-GCM self-test did not reject a reused nonce on %s; nonce-reuse protection is missing (incompatible Go version)", runtime.Version()))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// reusePanics reports whether re-encrypting with an already-used counter panics,
|
|
||||||
// as GCMWithXORCounterNonce is expected to.
|
|
||||||
func reusePanics(c noise.Cipher) (panicked bool) {
|
|
||||||
c.Encrypt(nil, 2, nil, nil)
|
|
||||||
defer func() {
|
|
||||||
if recover() != nil {
|
|
||||||
panicked = true
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
c.Encrypt(nil, 2, nil, nil)
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
@@ -1,48 +0,0 @@
|
|||||||
package noiseutil
|
|
||||||
|
|
||||||
import (
|
|
||||||
"crypto/cipher"
|
|
||||||
"crypto/fips140"
|
|
||||||
"encoding/hex"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/stretchr/testify/assert"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Ensure NewAESGCM validates the nonce is non-repeating
|
|
||||||
func TestNewAESGCM(t *testing.T) {
|
|
||||||
if !boringEnabled && !fips140.Enabled() {
|
|
||||||
t.Skip("TestNewAESGCM is only for fips140/boringcrypto")
|
|
||||||
}
|
|
||||||
|
|
||||||
key, _ := hex.DecodeString("feffe9928665731c6d6a8f9467308308feffe9928665731c6d6a8f9467308308")
|
|
||||||
iv, _ := hex.DecodeString("00000000facedbaddecaf888")
|
|
||||||
plaintext, _ := hex.DecodeString("d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39")
|
|
||||||
aad, _ := hex.DecodeString("feedfacedeadbeeffeedfacedeadbeefabaddad2")
|
|
||||||
expected, _ := hex.DecodeString("6a65c2edd45bd63c7e29f40e3d2ed8ba2b99f4c83135383d5676652f255059ceb24863ff10afb1089db701245da87fb88d3acd5f9dd0770cac220c3c04145caf25e190aeb775e7080401c628")
|
|
||||||
|
|
||||||
var keyArray [32]byte
|
|
||||||
copy(keyArray[:], key)
|
|
||||||
c := CipherAESGCM.Cipher(keyArray)
|
|
||||||
aead := c.(cipher.AEAD)
|
|
||||||
|
|
||||||
dst := aead.Seal([]byte{}, iv, plaintext, aad)
|
|
||||||
t.Logf("%x", dst)
|
|
||||||
assert.Equal(t, expected, dst)
|
|
||||||
|
|
||||||
// We expect this to fail since we are re-encrypting with a repeat IV
|
|
||||||
switch {
|
|
||||||
case boringEnabled:
|
|
||||||
assert.PanicsWithError(t, "boringcrypto: EVP_AEAD_CTX_seal failed", func() {
|
|
||||||
dst = aead.Seal([]byte{}, iv, plaintext, aad)
|
|
||||||
})
|
|
||||||
case fips140.Version() == "v1.0.0":
|
|
||||||
assert.PanicsWithValue(t, "crypto/cipher: counter decreased", func() {
|
|
||||||
dst = aead.Seal([]byte{}, iv, plaintext, aad)
|
|
||||||
})
|
|
||||||
default:
|
|
||||||
assert.PanicsWithValue(t, "crypto/cipher: counter decreased or remained the same", func() {
|
|
||||||
dst = aead.Seal([]byte{}, iv, plaintext, aad)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,13 +0,0 @@
|
|||||||
//go:build fips140enforce
|
|
||||||
|
|
||||||
package noiseutil
|
|
||||||
|
|
||||||
import (
|
|
||||||
"crypto/fips140"
|
|
||||||
)
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
if !fips140.Enforced() {
|
|
||||||
panic("Nebula compiled with fips140 expects FIPS140 to be enforced. Do not set GODEBUG=fips140, or if you do it must be set as GODEBUG=fips140=only")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
+4
-15
@@ -1,25 +1,14 @@
|
|||||||
//go:build !boringcrypto
|
//go:build !boringcrypto
|
||||||
|
// +build !boringcrypto
|
||||||
|
|
||||||
package noiseutil
|
package noiseutil
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"crypto/fips140"
|
|
||||||
|
|
||||||
"github.com/flynn/noise"
|
"github.com/flynn/noise"
|
||||||
)
|
)
|
||||||
|
|
||||||
// EncryptLockNeeded indicates if calls to Encrypt need a lock
|
// EncryptLockNeeded indicates if calls to Encrypt need a lock
|
||||||
var EncryptLockNeeded = fips140.Enabled()
|
const EncryptLockNeeded = false
|
||||||
|
|
||||||
var CipherAESGCM noise.CipherFunc = initAESGCM()
|
// CipherAESGCM is the standard noise.CipherAESGCM when boringcrypto is not enabled
|
||||||
|
var CipherAESGCM noise.CipherFunc = noise.CipherAESGCM
|
||||||
func initAESGCM() noise.CipherFunc {
|
|
||||||
if fips140.Enabled() {
|
|
||||||
return CipherAESGCMFIPS140
|
|
||||||
} else {
|
|
||||||
return noise.CipherAESGCM
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
var boringEnabled = false
|
|
||||||
@@ -0,0 +1,14 @@
|
|||||||
|
//go:build !boringcrypto
|
||||||
|
// +build !boringcrypto
|
||||||
|
|
||||||
|
package noiseutil
|
||||||
|
|
||||||
|
import (
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestEncryptLockNeeded(t *testing.T) {
|
||||||
|
assert.False(t, EncryptLockNeeded)
|
||||||
|
}
|
||||||
+46
-64
@@ -8,12 +8,12 @@ import (
|
|||||||
"net/netip"
|
"net/netip"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
|
"github.com/google/gopacket/layers"
|
||||||
"golang.org/x/net/ipv6"
|
"golang.org/x/net/ipv6"
|
||||||
|
|
||||||
"github.com/slackhq/nebula/firewall"
|
"github.com/slackhq/nebula/firewall"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/iputil"
|
"github.com/slackhq/nebula/iputil"
|
||||||
"github.com/slackhq/nebula/overlay/batch"
|
|
||||||
"golang.org/x/net/ipv4"
|
"golang.org/x/net/ipv4"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -23,11 +23,7 @@ const (
|
|||||||
|
|
||||||
var ErrOutOfWindow = errors.New("out of window packet")
|
var ErrOutOfWindow = errors.New("out of window packet")
|
||||||
|
|
||||||
// readOutsidePackets processes one received underlay packet.
|
func (f *Interface) readOutsidePackets(via ViaSender, out []byte, packet []byte, h *header.H, fwPacket *firewall.Packet, lhf *LightHouseHandler, nb []byte, q int, localCache firewall.ConntrackCache) {
|
||||||
// Message payloads are decrypted IN PLACE, so packet must stay untouched
|
|
||||||
// by the caller until the batcher for queue q has been flushed
|
|
||||||
func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxContext) {
|
|
||||||
h := rxc.h
|
|
||||||
err := h.Parse(packet)
|
err := h.Parse(packet)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
// Hole punch packets are 0 or 1 byte big, so lets ignore printing those errors
|
// Hole punch packets are 0 or 1 byte big, so lets ignore printing those errors
|
||||||
@@ -95,7 +91,7 @@ func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxCont
|
|||||||
if isMessageRelay {
|
if isMessageRelay {
|
||||||
hostinfo = f.hostMap.QueryRelayIndex(h.RemoteIndex)
|
hostinfo = f.hostMap.QueryRelayIndex(h.RemoteIndex)
|
||||||
} else {
|
} else {
|
||||||
hostinfo = f.hostMap.QueryIndexCached(h.RemoteIndex, rxc.hostmapCache)
|
hostinfo = f.hostMap.QueryIndex(h.RemoteIndex)
|
||||||
}
|
}
|
||||||
|
|
||||||
// At this point we should have a valid existing tunnel, verify and send
|
// At this point we should have a valid existing tunnel, verify and send
|
||||||
@@ -118,18 +114,17 @@ func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxCont
|
|||||||
// All remaining packets are encrypted
|
// All remaining packets are encrypted
|
||||||
if isMessageRelay {
|
if isMessageRelay {
|
||||||
// Relay packets are special, this branch should always early-return
|
// Relay packets are special, this branch should always early-return
|
||||||
err = hostinfo.ConnectionState.VerifyRelay(f.l, h.MessageCounter, packet, rxc.nb)
|
if err = hostinfo.ConnectionState.VerifyRelay(f.l, h.MessageCounter, packet, nb); err != nil {
|
||||||
if err != nil {
|
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
hostinfo.logger(f.l).Debug("Failed to verify relay packet", "error", err, "from", via, "header", h)
|
hostinfo.logger(f.l).Debug("Failed to verify relay packet", "error", err, "from", via, "header", h)
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
f.handleOutsideRelayPacket(hostinfo, via, packet, rxc)
|
f.handleOutsideRelayPacket(hostinfo, via, out, packet, h, fwPacket, lhf, nb, q, localCache)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
out, err := hostinfo.ConnectionState.Decrypt(f.l, h.MessageCounter, packet, rxc.nb)
|
out, err = hostinfo.ConnectionState.Decrypt(f.l, h.MessageCounter, out, packet, nb)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
hostinfo.logger(f.l).Debug("Failed to decrypt packet", "error", err, "from", via, "header", h)
|
hostinfo.logger(f.l).Debug("Failed to decrypt packet", "error", err, "from", via, "header", h)
|
||||||
@@ -145,7 +140,7 @@ func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxCont
|
|||||||
case header.Message:
|
case header.Message:
|
||||||
switch h.Subtype {
|
switch h.Subtype {
|
||||||
case header.MessageNone:
|
case header.MessageNone:
|
||||||
f.handleOutsideMessagePacket(hostinfo, h.MessageCounter, out, rxc)
|
f.handleOutsideMessagePacket(hostinfo, out, packet, fwPacket, nb, q, localCache)
|
||||||
default:
|
default:
|
||||||
hostinfo.logger(f.l).Error("IsValidSubType was true, but unexpected message subtype seen", "from", via, "header", h)
|
hostinfo.logger(f.l).Error("IsValidSubType was true, but unexpected message subtype seen", "from", via, "header", h)
|
||||||
return
|
return
|
||||||
@@ -153,21 +148,15 @@ func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxCont
|
|||||||
|
|
||||||
case header.LightHouse:
|
case header.LightHouse:
|
||||||
//TODO: assert via is not relayed
|
//TODO: assert via is not relayed
|
||||||
rxc.lhh.HandleRequest(via.UdpAddr, hostinfo.vpnAddrs, out, f)
|
lhf.HandleRequest(via.UdpAddr, hostinfo.vpnAddrs, out, f)
|
||||||
|
|
||||||
case header.Test:
|
case header.Test:
|
||||||
switch h.Subtype {
|
switch h.Subtype {
|
||||||
case header.TestReply:
|
case header.TestReply:
|
||||||
// No-op, useful for the Roaming and connectionManager side-effects above
|
// No-op, useful for the Roaming and connectionManager side-effects above
|
||||||
case header.TestRequest:
|
case header.TestRequest:
|
||||||
if header.MaxOverhead+len(out) > len(rxc.scratch) {
|
//recycle the input packet ciphertext as our output buffer
|
||||||
// A reply that cannot fit in scratch is dropped no matter the log level.
|
f.send(header.Test, header.TestReply, hostinfo.ConnectionState, hostinfo, out, nb, packet)
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
|
||||||
hostinfo.logger(f.l).Debug("dropping oversized test request", "payloadLen", len(out), "from", via)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
f.send(header.Test, header.TestReply, hostinfo.ConnectionState, hostinfo, out, rxc.nb, rxc.scratch[:0])
|
|
||||||
default:
|
default:
|
||||||
hostinfo.logger(f.l).Error("IsValidSubType was true, but unexpected test subtype seen", "from", via, "header", h)
|
hostinfo.logger(f.l).Error("IsValidSubType was true, but unexpected test subtype seen", "from", via, "header", h)
|
||||||
return
|
return
|
||||||
@@ -185,8 +174,7 @@ func (f *Interface) readOutsidePackets(via ViaSender, packet []byte, rxc *rxCont
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) handleOutsideRelayPacket(hostinfo *HostInfo, via ViaSender, packet []byte, rxc *rxContext) {
|
func (f *Interface) handleOutsideRelayPacket(hostinfo *HostInfo, via ViaSender, out []byte, packet []byte, h *header.H, fwPacket *firewall.Packet, lhf *LightHouseHandler, nb []byte, q int, localCache firewall.ConntrackCache) {
|
||||||
h := rxc.h
|
|
||||||
// Successfully validated the thing. Get rid of the Relay header and the AEAD tag
|
// Successfully validated the thing. Get rid of the Relay header and the AEAD tag
|
||||||
signedPayload := packet[header.Len : len(packet)-hostinfo.ConnectionState.dKey.Overhead()]
|
signedPayload := packet[header.Len : len(packet)-hostinfo.ConnectionState.dKey.Overhead()]
|
||||||
// Pull the Roaming parts up here, and return in all call paths.
|
// Pull the Roaming parts up here, and return in all call paths.
|
||||||
@@ -199,7 +187,9 @@ func (f *Interface) handleOutsideRelayPacket(hostinfo *HostInfo, via ViaSender,
|
|||||||
if !ok {
|
if !ok {
|
||||||
// The only way this happens is if hostmap has an index to the correct HostInfo, but the HostInfo is missing
|
// The only way this happens is if hostmap has an index to the correct HostInfo, but the HostInfo is missing
|
||||||
// its internal mapping. This should never happen.
|
// its internal mapping. This should never happen.
|
||||||
hostinfo.logger(f.l).Error("HostInfo missing remote relay index", "relayRemoteIndex", h.RemoteIndex)
|
hostinfo.logger(f.l).Error("HostInfo missing remote relay index",
|
||||||
|
"relayRemoteIndex", h.RemoteIndex,
|
||||||
|
)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -213,7 +203,7 @@ func (f *Interface) handleOutsideRelayPacket(hostinfo *HostInfo, via ViaSender,
|
|||||||
relay: relay,
|
relay: relay,
|
||||||
IsRelayed: true,
|
IsRelayed: true,
|
||||||
}
|
}
|
||||||
f.readOutsidePackets(via, signedPayload, rxc)
|
f.readOutsidePackets(via, out[:0], signedPayload, h, fwPacket, lhf, nb, q, localCache)
|
||||||
case ForwardingType:
|
case ForwardingType:
|
||||||
// Find the target HostInfo relay object
|
// Find the target HostInfo relay object
|
||||||
targetHI, targetRelay, err := f.hostMap.QueryVpnAddrsRelayFor(hostinfo.vpnAddrs, relay.PeerAddr)
|
targetHI, targetRelay, err := f.hostMap.QueryVpnAddrsRelayFor(hostinfo.vpnAddrs, relay.PeerAddr)
|
||||||
@@ -232,9 +222,8 @@ func (f *Interface) handleOutsideRelayPacket(hostinfo *HostInfo, via ViaSender,
|
|||||||
case ForwardingType:
|
case ForwardingType:
|
||||||
// Forward this packet through the relay tunnel, rebuilding it in place.
|
// Forward this packet through the relay tunnel, rebuilding it in place.
|
||||||
// Encode overwrites the old outer header, and the new AEAD tag lands where the old one was
|
// Encode overwrites the old outer header, and the new AEAD tag lands where the old one was
|
||||||
fwdBuf := packet[:0]
|
fwdBuf := packet[:0:len(packet)] // Cap to len(packet) to protect memory from a larger parent buffer
|
||||||
//todo it would potentially be nice to batch these
|
f.SendVia(targetHI, targetRelay, signedPayload, nb, fwdBuf, true)
|
||||||
f.SendVia(targetHI, targetRelay, signedPayload, rxc.nb, fwdBuf, true, rxc.q)
|
|
||||||
case TerminalType:
|
case TerminalType:
|
||||||
hostinfo.logger(f.l).Error("Unexpected Relay Type of Terminal")
|
hostinfo.logger(f.l).Error("Unexpected Relay Type of Terminal")
|
||||||
return
|
return
|
||||||
@@ -261,17 +250,12 @@ func (f *Interface) handleOutsideRelayPacket(hostinfo *HostInfo, via ViaSender,
|
|||||||
|
|
||||||
// closeTunnel closes a tunnel locally, it does not send a closeTunnel packet to the remote
|
// closeTunnel closes a tunnel locally, it does not send a closeTunnel packet to the remote
|
||||||
func (f *Interface) closeTunnel(hostInfo *HostInfo) {
|
func (f *Interface) closeTunnel(hostInfo *HostInfo) {
|
||||||
// Hold the hostmap lock across both the delete and the lighthouse eviction,
|
final := f.hostMap.DeleteHostInfo(hostInfo)
|
||||||
// to avoid a race with handshake completion.
|
if final {
|
||||||
f.hostMap.Lock()
|
|
||||||
defer f.hostMap.Unlock()
|
|
||||||
if !f.hostMap.unlockedDeleteHostInfo(hostInfo) {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// We no longer have any tunnels with this vpn addr, clear learned lighthouse state to lower memory usage
|
// We no longer have any tunnels with this vpn addr, clear learned lighthouse state to lower memory usage
|
||||||
f.lightHouse.DeleteVpnAddrs(hostInfo.vpnAddrs)
|
f.lightHouse.DeleteVpnAddrs(hostInfo.vpnAddrs)
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// sendCloseTunnel is a helper function to send a proper close tunnel packet to a remote
|
// sendCloseTunnel is a helper function to send a proper close tunnel packet to a remote
|
||||||
func (f *Interface) sendCloseTunnel(h *HostInfo) {
|
func (f *Interface) sendCloseTunnel(h *HostInfo) {
|
||||||
@@ -319,11 +303,7 @@ var (
|
|||||||
)
|
)
|
||||||
|
|
||||||
// newPacket validates and parses the interesting bits for the firewall out of the ip and sub protocol headers
|
// newPacket validates and parses the interesting bits for the firewall out of the ip and sub protocol headers
|
||||||
func newPacket(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
func newPacket(data []byte, incoming bool, fp *firewall.Packet) error {
|
||||||
// fp is reused across packets; reset the parse byproducts so an early-error return cannot
|
|
||||||
// leak the previous packet's offsets.
|
|
||||||
fp.IPHdrLen = 0
|
|
||||||
fp.FragAny = false
|
|
||||||
if len(data) < 1 {
|
if len(data) < 1 {
|
||||||
return ErrPacketTooShort
|
return ErrPacketTooShort
|
||||||
}
|
}
|
||||||
@@ -338,7 +318,7 @@ func newPacket(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
return ErrUnknownIPVersion
|
return ErrUnknownIPVersion
|
||||||
}
|
}
|
||||||
|
|
||||||
func parseV6(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
func parseV6(data []byte, incoming bool, fp *firewall.Packet) error {
|
||||||
dataLen := len(data)
|
dataLen := len(data)
|
||||||
if dataLen < ipv6.HeaderLen {
|
if dataLen < ipv6.HeaderLen {
|
||||||
return ErrIPv6PacketTooShort
|
return ErrIPv6PacketTooShort
|
||||||
@@ -355,15 +335,13 @@ func parseV6(data []byte, incoming bool, fp *firewall.ParsedPacket) 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, anyFragment, err := iputil.IPv6FindUpperProtocol(data)
|
proto, offset, isFragment, err := iputil.IPv6FindUpperProtocol(data)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return ErrIPv6PacketTooShort
|
||||||
}
|
}
|
||||||
|
|
||||||
fp.Protocol = proto
|
fp.Protocol = proto
|
||||||
fp.Fragment = isFragment
|
fp.Fragment = isFragment
|
||||||
fp.FragAny = anyFragment
|
|
||||||
fp.IPHdrLen = offset
|
|
||||||
if isFragment {
|
if isFragment {
|
||||||
// Non-first fragments carry no transport header, so we have no ports to read
|
// Non-first fragments carry no transport header, so we have no ports to read
|
||||||
fp.RemotePort = 0
|
fp.RemotePort = 0
|
||||||
@@ -371,15 +349,15 @@ func parseV6(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
switch proto {
|
switch layers.IPProtocol(proto) {
|
||||||
case iputil.IPProtocolICMPv6:
|
case layers.IPProtocolICMPv6:
|
||||||
// An ICMPv6 message is at least type, code and checksum, 4 bytes. Only echo carries more than we read.
|
// An ICMPv6 message is at least type, code and checksum, 4 bytes. Only echo carries more than we read.
|
||||||
if dataLen < offset+4 {
|
if dataLen < offset+4 {
|
||||||
return ErrIPv6PacketTooShort
|
return ErrIPv6PacketTooShort
|
||||||
}
|
}
|
||||||
fp.LocalPort = 0 //incoming vs outgoing doesn't matter for icmpv6
|
fp.LocalPort = 0 //incoming vs outgoing doesn't matter for icmpv6
|
||||||
switch data[offset] { //icmp type
|
switch data[offset] { //icmp type
|
||||||
case iputil.ICMPv6TypeEchoRequest, iputil.ICMPv6TypeEchoReply:
|
case layers.ICMPv6TypeEchoRequest, layers.ICMPv6TypeEchoReply:
|
||||||
if dataLen < offset+6 {
|
if dataLen < offset+6 {
|
||||||
return ErrIPv6PacketTooShort
|
return ErrIPv6PacketTooShort
|
||||||
}
|
}
|
||||||
@@ -388,7 +366,7 @@ func parseV6(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
fp.RemotePort = 0
|
fp.RemotePort = 0
|
||||||
}
|
}
|
||||||
|
|
||||||
case iputil.IPProtocolTCP, iputil.IPProtocolUDP:
|
case layers.IPProtocolTCP, layers.IPProtocolUDP:
|
||||||
if dataLen < offset+4 {
|
if dataLen < offset+4 {
|
||||||
return ErrIPv6PacketTooShort
|
return ErrIPv6PacketTooShort
|
||||||
}
|
}
|
||||||
@@ -409,7 +387,7 @@ func parseV6(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func parseV4(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
func parseV4(data []byte, incoming bool, fp *firewall.Packet) error {
|
||||||
// Do we at least have an ipv4 header worth of data?
|
// Do we at least have an ipv4 header worth of data?
|
||||||
if len(data) < ipv4.HeaderLen {
|
if len(data) < ipv4.HeaderLen {
|
||||||
return ErrIPv4PacketTooShort
|
return ErrIPv4PacketTooShort
|
||||||
@@ -426,10 +404,6 @@ func parseV4(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
// Check if this is the second or further fragment of a fragmented packet.
|
// Check if this is the second or further fragment of a fragmented packet.
|
||||||
flagsfrags := binary.BigEndian.Uint16(data[6:8])
|
flagsfrags := binary.BigEndian.Uint16(data[6:8])
|
||||||
fp.Fragment = (flagsfrags & 0x1FFF) != 0
|
fp.Fragment = (flagsfrags & 0x1FFF) != 0
|
||||||
// Any fragmentation at all (MF or offset): first fragments have readable ports for the
|
|
||||||
// firewall but must never be coalesced.
|
|
||||||
fp.FragAny = (flagsfrags & 0x3fff) != 0
|
|
||||||
fp.IPHdrLen = ihl
|
|
||||||
|
|
||||||
// Firewall handles protocol checks
|
// Firewall handles protocol checks
|
||||||
fp.Protocol = data[9]
|
fp.Protocol = data[9]
|
||||||
@@ -437,7 +411,7 @@ func parseV4(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
// Accounting for a variable header length, do we have enough data for our src/dst tuples?
|
// Accounting for a variable header length, do we have enough data for our src/dst tuples?
|
||||||
minLen := ihl
|
minLen := ihl
|
||||||
if !fp.Fragment {
|
if !fp.Fragment {
|
||||||
if fp.Protocol == iputil.IPProtocolICMP {
|
if fp.Protocol == firewall.ProtoICMP {
|
||||||
minLen += minFwPacketLen + 2
|
minLen += minFwPacketLen + 2
|
||||||
} else {
|
} else {
|
||||||
minLen += minFwPacketLen
|
minLen += minFwPacketLen
|
||||||
@@ -459,7 +433,7 @@ func parseV4(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
if fp.Fragment {
|
if fp.Fragment {
|
||||||
fp.RemotePort = 0
|
fp.RemotePort = 0
|
||||||
fp.LocalPort = 0
|
fp.LocalPort = 0
|
||||||
} else if fp.Protocol == iputil.IPProtocolICMP { //note that orientation doesn't matter on ICMP
|
} else if fp.Protocol == firewall.ProtoICMP { //note that orientation doesn't matter on ICMP
|
||||||
fp.RemotePort = binary.BigEndian.Uint16(data[ihl+4 : ihl+6]) //identifier
|
fp.RemotePort = binary.BigEndian.Uint16(data[ihl+4 : ihl+6]) //identifier
|
||||||
fp.LocalPort = 0 //code would be uint16(data[ihl+1])
|
fp.LocalPort = 0 //code would be uint16(data[ihl+1])
|
||||||
} else if incoming {
|
} else if incoming {
|
||||||
@@ -473,23 +447,31 @@ func parseV4(data []byte, incoming bool, fp *firewall.ParsedPacket) error {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) handleOutsideMessagePacket(hostinfo *HostInfo, messageCounter uint64, out []byte, rxc *rxContext) {
|
func (f *Interface) handleOutsideMessagePacket(hostinfo *HostInfo, out []byte, packet []byte, fwPacket *firewall.Packet, nb []byte, q int, localCache firewall.ConntrackCache) {
|
||||||
err := newPacket(out, true, rxc.fwPacket)
|
err := newPacket(out, true, fwPacket)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
hostinfo.logger(f.l).Warn("Error while validating inbound packet", "error", err, "packet", out)
|
hostinfo.logger(f.l).Warn("Error while validating inbound packet",
|
||||||
|
"error", err,
|
||||||
|
"packet", out,
|
||||||
|
)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
dropReason := f.firewall.Drop(rxc.fwPacket.Packet, true, hostinfo, f.pki.GetCAPool(), rxc.ctCache.Get())
|
dropReason := f.firewall.Drop(*fwPacket, true, hostinfo, f.pki.GetCAPool(), localCache)
|
||||||
if dropReason != nil {
|
if dropReason != nil {
|
||||||
f.rejectOutside(out, hostinfo.ConnectionState, hostinfo, rxc.nb, rxc.scratch, rxc.q)
|
// NOTE: We give `packet` as the `out` here since we already decrypted from it and we don't need it anymore
|
||||||
|
// This gives us a buffer to build the reject packet in
|
||||||
|
f.rejectOutside(out, hostinfo.ConnectionState, hostinfo, nb, packet, q)
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
hostinfo.logger(f.l).Debug("dropping inbound packet", "fwPacket", rxc.fwPacket, "reason", dropReason)
|
hostinfo.logger(f.l).Debug("dropping inbound packet",
|
||||||
|
"fwPacket", fwPacket,
|
||||||
|
"reason", dropReason,
|
||||||
|
)
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
err = f.batchers[rxc.q].Commit(out, batch.SortKey{Epoch: hostinfo.ConnectionState.epoch, Counter: messageCounter}, rxc.fwPacket)
|
_, err = f.readers[q].Write(out)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
f.l.Error("Failed to write to tun", "error", err)
|
f.l.Error("Failed to write to tun", "error", err)
|
||||||
}
|
}
|
||||||
|
|||||||
+24
-110
@@ -9,7 +9,6 @@ import (
|
|||||||
|
|
||||||
"github.com/google/gopacket"
|
"github.com/google/gopacket"
|
||||||
"github.com/google/gopacket/layers"
|
"github.com/google/gopacket/layers"
|
||||||
"github.com/slackhq/nebula/iputil"
|
|
||||||
|
|
||||||
"github.com/slackhq/nebula/firewall"
|
"github.com/slackhq/nebula/firewall"
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
@@ -19,7 +18,7 @@ import (
|
|||||||
)
|
)
|
||||||
|
|
||||||
func Test_newPacket(t *testing.T) {
|
func Test_newPacket(t *testing.T) {
|
||||||
p := &firewall.ParsedPacket{}
|
p := &firewall.Packet{}
|
||||||
|
|
||||||
// length fails
|
// length fails
|
||||||
err := newPacket([]byte{}, true, p)
|
err := newPacket([]byte{}, true, p)
|
||||||
@@ -59,7 +58,7 @@ func Test_newPacket(t *testing.T) {
|
|||||||
Src: net.IPv4(10, 0, 0, 1),
|
Src: net.IPv4(10, 0, 0, 1),
|
||||||
Dst: net.IPv4(10, 0, 0, 2),
|
Dst: net.IPv4(10, 0, 0, 2),
|
||||||
Options: []byte{0, 1, 0, 2},
|
Options: []byte{0, 1, 0, 2},
|
||||||
Protocol: iputil.IPProtocolTCP,
|
Protocol: firewall.ProtoTCP,
|
||||||
}
|
}
|
||||||
|
|
||||||
b, _ = h.Marshal()
|
b, _ = h.Marshal()
|
||||||
@@ -67,7 +66,7 @@ func Test_newPacket(t *testing.T) {
|
|||||||
err = newPacket(b, true, p)
|
err = newPacket(b, true, p)
|
||||||
|
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolTCP), p.Protocol)
|
assert.Equal(t, uint8(firewall.ProtoTCP), p.Protocol)
|
||||||
assert.Equal(t, netip.MustParseAddr("10.0.0.2"), p.LocalAddr)
|
assert.Equal(t, netip.MustParseAddr("10.0.0.2"), p.LocalAddr)
|
||||||
assert.Equal(t, netip.MustParseAddr("10.0.0.1"), p.RemoteAddr)
|
assert.Equal(t, netip.MustParseAddr("10.0.0.1"), p.RemoteAddr)
|
||||||
assert.Equal(t, uint16(3), p.RemotePort)
|
assert.Equal(t, uint16(3), p.RemotePort)
|
||||||
@@ -98,7 +97,7 @@ func Test_newPacket(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func Test_newPacket_v6(t *testing.T) {
|
func Test_newPacket_v6(t *testing.T) {
|
||||||
p := &firewall.ParsedPacket{}
|
p := &firewall.Packet{}
|
||||||
|
|
||||||
// invalid ipv6
|
// invalid ipv6
|
||||||
ip := layers.IPv6{
|
ip := layers.IPv6{
|
||||||
@@ -117,7 +116,7 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
|
|
||||||
err = newPacket(buffer.Bytes(), true, p)
|
err = newPacket(buffer.Bytes(), true, p)
|
||||||
require.ErrorIs(t, err, iputil.ErrIPv6CouldNotFindPayload)
|
require.ErrorIs(t, err, ErrIPv6PacketTooShort)
|
||||||
|
|
||||||
// A v6 packet with a hop-by-hop extension
|
// A v6 packet with a hop-by-hop extension
|
||||||
// ICMPv6 Payload (Echo Request)
|
// ICMPv6 Payload (Echo Request)
|
||||||
@@ -151,12 +150,12 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
// A full IPv6 header and 1 byte in the first extension, but missing
|
// A full IPv6 header and 1 byte in the first extension, but missing
|
||||||
// the length byte.
|
// the length byte.
|
||||||
err = newPacket(buffer.Bytes()[:41], true, p)
|
err = newPacket(buffer.Bytes()[:41], true, p)
|
||||||
require.ErrorIs(t, err, iputil.ErrIPv6CouldNotFindPayload)
|
require.ErrorIs(t, err, ErrIPv6PacketTooShort)
|
||||||
|
|
||||||
// A full IPv6 header plus 1 full extension, but only 1 byte of the
|
// A full IPv6 header plus 1 full extension, but only 1 byte of the
|
||||||
// next layer, missing length byte
|
// next layer, missing length byte
|
||||||
err = newPacket(buffer.Bytes()[:49], true, p)
|
err = newPacket(buffer.Bytes()[:49], true, p)
|
||||||
require.ErrorIs(t, err, iputil.ErrIPv6CouldNotFindPayload)
|
require.ErrorIs(t, err, ErrIPv6PacketTooShort)
|
||||||
err = nil
|
err = nil
|
||||||
|
|
||||||
// A good ICMP packet
|
// A good ICMP packet
|
||||||
@@ -240,7 +239,7 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
// A good UDP packet
|
// A good UDP packet
|
||||||
ip = layers.IPv6{
|
ip = layers.IPv6{
|
||||||
Version: 6,
|
Version: 6,
|
||||||
NextHeader: iputil.IPProtocolUDP,
|
NextHeader: firewall.ProtoUDP,
|
||||||
HopLimit: 128,
|
HopLimit: 128,
|
||||||
SrcIP: net.IPv6linklocalallrouters,
|
SrcIP: net.IPv6linklocalallrouters,
|
||||||
DstIP: net.IPv6linklocalallnodes,
|
DstIP: net.IPv6linklocalallnodes,
|
||||||
@@ -263,7 +262,7 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
// incoming
|
// incoming
|
||||||
err = newPacket(b, true, p)
|
err = newPacket(b, true, p)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolUDP), p.Protocol)
|
assert.Equal(t, uint8(firewall.ProtoUDP), p.Protocol)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.RemoteAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.RemoteAddr)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.LocalAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.LocalAddr)
|
||||||
assert.Equal(t, uint16(36123), p.RemotePort)
|
assert.Equal(t, uint16(36123), p.RemotePort)
|
||||||
@@ -273,7 +272,7 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
// outgoing
|
// outgoing
|
||||||
err = newPacket(b, false, p)
|
err = newPacket(b, false, p)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolUDP), p.Protocol)
|
assert.Equal(t, uint8(firewall.ProtoUDP), p.Protocol)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.LocalAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.LocalAddr)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.RemoteAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.RemoteAddr)
|
||||||
assert.Equal(t, uint16(36123), p.LocalPort)
|
assert.Equal(t, uint16(36123), p.LocalPort)
|
||||||
@@ -290,7 +289,7 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
// incoming
|
// incoming
|
||||||
err = newPacket(b, true, p)
|
err = newPacket(b, true, p)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolTCP), p.Protocol)
|
assert.Equal(t, uint8(firewall.ProtoTCP), p.Protocol)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.RemoteAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.RemoteAddr)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.LocalAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.LocalAddr)
|
||||||
assert.Equal(t, uint16(36123), p.RemotePort)
|
assert.Equal(t, uint16(36123), p.RemotePort)
|
||||||
@@ -300,7 +299,7 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
// outgoing
|
// outgoing
|
||||||
err = newPacket(b, false, p)
|
err = newPacket(b, false, p)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolTCP), p.Protocol)
|
assert.Equal(t, uint8(firewall.ProtoTCP), p.Protocol)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.LocalAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.LocalAddr)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.RemoteAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.RemoteAddr)
|
||||||
assert.Equal(t, uint16(36123), p.LocalPort)
|
assert.Equal(t, uint16(36123), p.LocalPort)
|
||||||
@@ -345,7 +344,7 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
|
|
||||||
err = newPacket(b, true, p)
|
err = newPacket(b, true, p)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolUDP), p.Protocol)
|
assert.Equal(t, uint8(firewall.ProtoUDP), p.Protocol)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.RemoteAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::2"), p.RemoteAddr)
|
||||||
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.LocalAddr)
|
assert.Equal(t, netip.MustParseAddr("ff02::1"), p.LocalAddr)
|
||||||
assert.Equal(t, uint16(36123), p.RemotePort)
|
assert.Equal(t, uint16(36123), p.RemotePort)
|
||||||
@@ -354,16 +353,16 @@ func Test_newPacket_v6(t *testing.T) {
|
|||||||
|
|
||||||
// Ensure buffer bounds checking during processing, a truncated AH header can't reach the payload
|
// Ensure buffer bounds checking during processing, a truncated AH header can't reach the payload
|
||||||
err = newPacket(b[:41], true, p)
|
err = newPacket(b[:41], true, p)
|
||||||
require.ErrorIs(t, err, iputil.ErrIPv6CouldNotFindPayload)
|
require.ErrorIs(t, err, ErrIPv6PacketTooShort)
|
||||||
|
|
||||||
// Invalid AH header
|
// Invalid AH header
|
||||||
b = buffer.Bytes()
|
b = buffer.Bytes()
|
||||||
err = newPacket(b, true, p)
|
err = newPacket(b, true, p)
|
||||||
require.ErrorIs(t, err, iputil.ErrIPv6CouldNotFindPayload)
|
require.ErrorIs(t, err, ErrIPv6PacketTooShort)
|
||||||
}
|
}
|
||||||
|
|
||||||
func Test_newPacket_ipv6Fragment(t *testing.T) {
|
func Test_newPacket_ipv6Fragment(t *testing.T) {
|
||||||
p := &firewall.ParsedPacket{}
|
p := &firewall.Packet{}
|
||||||
|
|
||||||
ip := &layers.IPv6{
|
ip := &layers.IPv6{
|
||||||
Version: 6,
|
Version: 6,
|
||||||
@@ -466,7 +465,7 @@ func Test_newPacket_ipv6Fragment(t *testing.T) {
|
|||||||
|
|
||||||
// Too short of a fragment packet
|
// Too short of a fragment packet
|
||||||
err = newPacket(secondFrag[:len(secondFrag)-10], false, p)
|
err = newPacket(secondFrag[:len(secondFrag)-10], false, p)
|
||||||
require.ErrorIs(t, err, iputil.ErrIPv6CouldNotFindPayload)
|
require.ErrorIs(t, err, ErrIPv6PacketTooShort)
|
||||||
}
|
}
|
||||||
|
|
||||||
func BenchmarkParseV6(b *testing.B) {
|
func BenchmarkParseV6(b *testing.B) {
|
||||||
@@ -543,7 +542,7 @@ func BenchmarkParseV6(b *testing.B) {
|
|||||||
secondFrag = append(secondFrag, fragHeader...)
|
secondFrag = append(secondFrag, fragHeader...)
|
||||||
secondFrag = append(secondFrag, []byte{0xde, 0xad, 0xbe, 0xef}...)
|
secondFrag = append(secondFrag, []byte{0xde, 0xad, 0xbe, 0xef}...)
|
||||||
|
|
||||||
fp := &firewall.ParsedPacket{}
|
fp := &firewall.Packet{}
|
||||||
|
|
||||||
b.Run("Normal", func(b *testing.B) {
|
b.Run("Normal", func(b *testing.B) {
|
||||||
for i := 0; i < b.N; i++ {
|
for i := 0; i < b.N; i++ {
|
||||||
@@ -667,7 +666,7 @@ func serializeAH(ah *layers.IPSecAH) []byte {
|
|||||||
// host OS parses the real header, a firewall port/proto bypass. The fix makes parseV6 land
|
// host OS parses the real header, a firewall port/proto bypass. The fix makes parseV6 land
|
||||||
// on the same offset the host does.
|
// on the same offset the host does.
|
||||||
func Test_newPacket_v6ExtHeaderOverflow(t *testing.T) {
|
func Test_newPacket_v6ExtHeaderOverflow(t *testing.T) {
|
||||||
p := &firewall.ParsedPacket{}
|
p := &firewall.Packet{}
|
||||||
|
|
||||||
const (
|
const (
|
||||||
hdrLen = 40 // IPv6 header
|
hdrLen = 40 // IPv6 header
|
||||||
@@ -679,7 +678,7 @@ func Test_newPacket_v6ExtHeaderOverflow(t *testing.T) {
|
|||||||
pkt := make([]byte, realTCPAt+4)
|
pkt := make([]byte, realTCPAt+4)
|
||||||
pkt[0] = 0x60 // version 6
|
pkt[0] = 0x60 // version 6
|
||||||
pkt[6] = byte(layers.IPProtocolIPv6Destination) // NextHeader -> Destination Options
|
pkt[6] = byte(layers.IPProtocolIPv6Destination) // NextHeader -> Destination Options
|
||||||
pkt[40] = byte(iputil.IPProtocolTCP) // Dest-Options NextHeader -> TCP
|
pkt[40] = byte(firewall.ProtoTCP) // Dest-Options NextHeader -> TCP
|
||||||
pkt[41] = 255 // HdrExtLen = 255
|
pkt[41] = 255 // HdrExtLen = 255
|
||||||
|
|
||||||
// Forged transport header at the pre-fix (wrong) offset: dst port 443.
|
// Forged transport header at the pre-fix (wrong) offset: dst port 443.
|
||||||
@@ -688,7 +687,7 @@ func Test_newPacket_v6ExtHeaderOverflow(t *testing.T) {
|
|||||||
binary.BigEndian.PutUint16(pkt[realTCPAt+2:realTCPAt+4], 22)
|
binary.BigEndian.PutUint16(pkt[realTCPAt+2:realTCPAt+4], 22)
|
||||||
|
|
||||||
require.NoError(t, newPacket(pkt, true, p))
|
require.NoError(t, newPacket(pkt, true, p))
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolTCP), p.Protocol)
|
assert.Equal(t, uint8(firewall.ProtoTCP), p.Protocol)
|
||||||
// LocalPort is the destination port for incoming traffic. It must be the real port (22)
|
// LocalPort is the destination port for incoming traffic. It must be the real port (22)
|
||||||
// the host delivers to, not the forged 443 at the overflowed offset.
|
// the host delivers to, not the forged 443 at the overflowed offset.
|
||||||
assert.Equal(t, uint16(22), p.LocalPort, "firewall must parse the real transport header, not the overflowed offset")
|
assert.Equal(t, uint16(22), p.LocalPort, "firewall must parse the real transport header, not the overflowed offset")
|
||||||
@@ -698,7 +697,7 @@ func Test_newPacket_v6ExtHeaderOverflow(t *testing.T) {
|
|||||||
// advances the walk past the end of the packet. The upper layer protocol's header isn't actually present,
|
// advances the walk past the end of the packet. The upper layer protocol's header isn't actually present,
|
||||||
// so parseV6 must drop the packet rather than classify it as the terminal protocol with no ports.
|
// so parseV6 must drop the packet rather than classify it as the terminal protocol with no ports.
|
||||||
func Test_newPacket_v6ExtHeaderPastBuffer(t *testing.T) {
|
func Test_newPacket_v6ExtHeaderPastBuffer(t *testing.T) {
|
||||||
p := &firewall.ParsedPacket{}
|
p := &firewall.Packet{}
|
||||||
|
|
||||||
pkt := make([]byte, 48)
|
pkt := make([]byte, 48)
|
||||||
pkt[0] = 0x60
|
pkt[0] = 0x60
|
||||||
@@ -707,7 +706,7 @@ func Test_newPacket_v6ExtHeaderPastBuffer(t *testing.T) {
|
|||||||
pkt[40] = byte(layers.IPProtocolSCTP) // Dest Options next header = SCTP
|
pkt[40] = byte(layers.IPProtocolSCTP) // Dest Options next header = SCTP
|
||||||
pkt[41] = 255 // declared length (255+1)*8 = 2048, past the 48 byte buffer
|
pkt[41] = 255 // declared length (255+1)*8 = 2048, past the 48 byte buffer
|
||||||
|
|
||||||
require.ErrorIs(t, newPacket(pkt, true, p), iputil.ErrIPv6CouldNotFindPayload)
|
require.ErrorIs(t, newPacket(pkt, true, p), ErrIPv6PacketTooShort)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Test_newPacket_v6ExtHeaderConfusion is a regression test for parseV6 walking any unrecognized
|
// Test_newPacket_v6ExtHeaderConfusion is a regression test for parseV6 walking any unrecognized
|
||||||
@@ -717,7 +716,7 @@ func Test_newPacket_v6ExtHeaderPastBuffer(t *testing.T) {
|
|||||||
// would trust while the host delivered the real SCTP datagram. The fix fails closed: the packet
|
// would trust while the host delivered the real SCTP datagram. The fix fails closed: the packet
|
||||||
// is classified as its true protocol with no ports, so it only matches an `any` rule.
|
// is classified as its true protocol with no ports, so it only matches an `any` rule.
|
||||||
func Test_newPacket_v6ExtHeaderConfusion(t *testing.T) {
|
func Test_newPacket_v6ExtHeaderConfusion(t *testing.T) {
|
||||||
p := &firewall.ParsedPacket{}
|
p := &firewall.Packet{}
|
||||||
|
|
||||||
pkt := make([]byte, 52)
|
pkt := make([]byte, 52)
|
||||||
pkt[0] = 0x60 // version 6
|
pkt[0] = 0x60 // version 6
|
||||||
@@ -756,88 +755,3 @@ func Test_newPacket_v6ExtHeaderConfusion(t *testing.T) {
|
|||||||
assert.Equal(t, uint16(0), p.LocalPort)
|
assert.Equal(t, uint16(0), p.LocalPort)
|
||||||
assert.False(t, p.Fragment)
|
assert.False(t, p.Fragment)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Test_newPacket_parsedFields pins the ParsedPacket byproducts the RX
|
|
||||||
// batcher consumes: IPHdrLen (the true L4 offset) and FragAny (any fragment
|
|
||||||
// shape at all — unlike Packet.Fragment, which is port-oriented and true
|
|
||||||
// only for non-first fragments).
|
|
||||||
func Test_newPacket_parsedFields(t *testing.T) {
|
|
||||||
p := &firewall.ParsedPacket{}
|
|
||||||
|
|
||||||
// Plain IPv4 TCP, IHL 20: L4 offset 20, no fragment shape.
|
|
||||||
v4 := make([]byte, 28)
|
|
||||||
v4[0] = 0x45
|
|
||||||
v4[9] = iputil.IPProtocolTCP
|
|
||||||
binary.BigEndian.PutUint16(v4[6:8], 0x4000) // DF only
|
|
||||||
require.NoError(t, newPacket(v4, true, p))
|
|
||||||
assert.Equal(t, 20, p.IPHdrLen)
|
|
||||||
assert.False(t, p.FragAny)
|
|
||||||
assert.False(t, p.Fragment)
|
|
||||||
|
|
||||||
// IPv4 first fragment (MF set, offset 0): the firewall can read ports
|
|
||||||
// (Fragment false) but the coalescer must not touch it (FragAny true).
|
|
||||||
ff := make([]byte, 28)
|
|
||||||
ff[0] = 0x45
|
|
||||||
ff[9] = iputil.IPProtocolUDP
|
|
||||||
binary.BigEndian.PutUint16(ff[6:8], 0x2000) // MF, offset 0
|
|
||||||
require.NoError(t, newPacket(ff, true, p))
|
|
||||||
assert.False(t, p.Fragment)
|
|
||||||
assert.True(t, p.FragAny)
|
|
||||||
assert.Equal(t, 20, p.IPHdrLen)
|
|
||||||
|
|
||||||
// IPv4 non-first fragment (nonzero offset): both flags set.
|
|
||||||
nf := make([]byte, 28)
|
|
||||||
nf[0] = 0x45
|
|
||||||
nf[9] = iputil.IPProtocolUDP
|
|
||||||
binary.BigEndian.PutUint16(nf[6:8], 0x00b9)
|
|
||||||
require.NoError(t, newPacket(nf, true, p))
|
|
||||||
assert.True(t, p.Fragment)
|
|
||||||
assert.True(t, p.FragAny)
|
|
||||||
|
|
||||||
// IPv4 with options (IHL 24): IPHdrLen tracks the real L4 offset.
|
|
||||||
opts := make([]byte, 32)
|
|
||||||
opts[0] = 0x46
|
|
||||||
opts[9] = iputil.IPProtocolTCP
|
|
||||||
binary.BigEndian.PutUint16(opts[6:8], 0x4000)
|
|
||||||
require.NoError(t, newPacket(opts, true, p))
|
|
||||||
assert.Equal(t, 24, p.IPHdrLen)
|
|
||||||
assert.False(t, p.FragAny)
|
|
||||||
|
|
||||||
// Plain IPv6 TCP: L4 at 40.
|
|
||||||
v6 := make([]byte, 60)
|
|
||||||
v6[0] = 0x60
|
|
||||||
v6[6] = iputil.IPProtocolTCP
|
|
||||||
require.NoError(t, newPacket(v6, true, p))
|
|
||||||
assert.Equal(t, 40, p.IPHdrLen)
|
|
||||||
assert.False(t, p.FragAny)
|
|
||||||
|
|
||||||
// IPv6 hop-by-hop then TCP: IPHdrLen lands past the extension header.
|
|
||||||
hbh := make([]byte, 60)
|
|
||||||
hbh[0] = 0x60
|
|
||||||
hbh[6] = 0 // hop-by-hop
|
|
||||||
hbh[40] = iputil.IPProtocolTCP
|
|
||||||
hbh[41] = 0 // HdrExtLen 0 -> 8-byte header
|
|
||||||
require.NoError(t, newPacket(hbh, true, p))
|
|
||||||
assert.Equal(t, 48, p.IPHdrLen)
|
|
||||||
assert.False(t, p.FragAny)
|
|
||||||
|
|
||||||
// IPv6 first fragment: terminal proto resolved, FragAny set, Fragment not.
|
|
||||||
f6 := make([]byte, 60)
|
|
||||||
f6[0] = 0x60
|
|
||||||
f6[6] = 44 // fragment extension header
|
|
||||||
f6[40] = iputil.IPProtocolUDP
|
|
||||||
require.NoError(t, newPacket(f6, true, p))
|
|
||||||
assert.True(t, p.FragAny)
|
|
||||||
assert.False(t, p.Fragment)
|
|
||||||
assert.Equal(t, uint8(iputil.IPProtocolUDP), p.Protocol)
|
|
||||||
|
|
||||||
// IPv6 non-first fragment: both set, walk stops at the fragment header.
|
|
||||||
f6n := make([]byte, 60)
|
|
||||||
f6n[0] = 0x60
|
|
||||||
f6n[6] = 44
|
|
||||||
f6n[40] = iputil.IPProtocolUDP
|
|
||||||
binary.BigEndian.PutUint16(f6n[42:44], 0x0008)
|
|
||||||
require.NoError(t, newPacket(f6n, true, p))
|
|
||||||
assert.True(t, p.Fragment)
|
|
||||||
assert.True(t, p.FragAny)
|
|
||||||
}
|
|
||||||
@@ -1,187 +0,0 @@
|
|||||||
package batch
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/binary"
|
|
||||||
"math/rand"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
// The checksum-seeding helpers feed the virtio NEEDS_CSUM contract: the L4
|
|
||||||
// checksum field is pre-loaded with the folded (not inverted) pseudo-header
|
|
||||||
// sum, and the kernel later adds the L4 byte sum and inverts. A wrong seed
|
|
||||||
// produces packets every receiver silently drops, with nothing failing on
|
|
||||||
// our side — so these tests check the helpers against an independent
|
|
||||||
// RFC 1071 reference built from explicit pseudo-header bytes, never against
|
|
||||||
// the production checksum code.
|
|
||||||
|
|
||||||
// refSum accumulates big-endian 16-bit words of b (odd tail zero-padded)
|
|
||||||
// into a wide one's-complement accumulator.
|
|
||||||
func refSum(b []byte) uint64 {
|
|
||||||
var s uint64
|
|
||||||
for i := 0; i+1 < len(b); i += 2 {
|
|
||||||
s += uint64(b[i])<<8 | uint64(b[i+1])
|
|
||||||
}
|
|
||||||
if len(b)%2 == 1 {
|
|
||||||
s += uint64(b[len(b)-1]) << 8
|
|
||||||
}
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
// refFold folds a wide one's-complement accumulator to 16 bits.
|
|
||||||
func refFold(s uint64) uint16 {
|
|
||||||
for s>>16 != 0 {
|
|
||||||
s = s&0xffff + s>>16
|
|
||||||
}
|
|
||||||
return uint16(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestFoldOnceNoInvertEdgeCases(t *testing.T) {
|
|
||||||
cases := []uint32{
|
|
||||||
0, 1, 0xffff,
|
|
||||||
0x10000, // single carry
|
|
||||||
0x1fffe, // 0xffff + 0xffff: carry produces another 0xffff
|
|
||||||
0xffff0000, // high half only
|
|
||||||
0xfffeffff, // fold yields 0x1fffd: needs a second fold
|
|
||||||
0xffffffff, // worst case
|
|
||||||
0x00010001, // simple two-word
|
|
||||||
}
|
|
||||||
for _, c := range cases {
|
|
||||||
want := refFold(uint64(c))
|
|
||||||
if got := foldOnceNoInvert(c); got != want {
|
|
||||||
t.Errorf("foldOnceNoInvert(%#x) = %#x, want %#x", c, got, want)
|
|
||||||
}
|
|
||||||
// Folding a folded value must be a no-op.
|
|
||||||
if got := foldOnceNoInvert(uint32(foldOnceNoInvert(c))); got != foldOnceNoInvert(c) {
|
|
||||||
t.Errorf("foldOnceNoInvert not idempotent at %#x", c)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPseudoSumIPv4MatchesReference(t *testing.T) {
|
|
||||||
cases := []struct {
|
|
||||||
name string
|
|
||||||
src, dst [4]byte
|
|
||||||
proto byte
|
|
||||||
l4Len int
|
|
||||||
}{
|
|
||||||
{"simple", [4]byte{10, 0, 0, 1}, [4]byte{10, 0, 0, 2}, 6, 20},
|
|
||||||
{"zero-len", [4]byte{192, 168, 1, 1}, [4]byte{192, 168, 1, 2}, 17, 0},
|
|
||||||
{"max-len", [4]byte{1, 2, 3, 4}, [4]byte{5, 6, 7, 8}, 6, 65535},
|
|
||||||
{"carry-heavy", [4]byte{255, 255, 255, 255}, [4]byte{255, 255, 255, 254}, 17, 65535},
|
|
||||||
{"broadcastish", [4]byte{255, 255, 255, 255}, [4]byte{255, 255, 255, 255}, 255, 65535},
|
|
||||||
}
|
|
||||||
for _, c := range cases {
|
|
||||||
t.Run(c.name, func(t *testing.T) {
|
|
||||||
// RFC 793 pseudo-header: src(4) dst(4) zero(1) proto(1) len(2).
|
|
||||||
ph := make([]byte, 12)
|
|
||||||
copy(ph[0:4], c.src[:])
|
|
||||||
copy(ph[4:8], c.dst[:])
|
|
||||||
ph[9] = c.proto
|
|
||||||
binary.BigEndian.PutUint16(ph[10:12], uint16(c.l4Len))
|
|
||||||
want := refFold(refSum(ph))
|
|
||||||
|
|
||||||
got := foldOnceNoInvert(pseudoSumIPv4(c.src[:], c.dst[:], c.proto, c.l4Len))
|
|
||||||
if got != want {
|
|
||||||
t.Errorf("fold(pseudoSumIPv4) = %#x, want %#x", got, want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPseudoSumIPv6MatchesReference(t *testing.T) {
|
|
||||||
ones := func(b byte) (a [16]byte) {
|
|
||||||
for i := range a {
|
|
||||||
a[i] = b
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
cases := []struct {
|
|
||||||
name string
|
|
||||||
src, dst [16]byte
|
|
||||||
proto byte
|
|
||||||
l4Len int
|
|
||||||
}{
|
|
||||||
{"simple", [16]byte{0xfe, 0x80, 15: 1}, [16]byte{0xfe, 0x80, 15: 2}, 6, 20},
|
|
||||||
{"zero-len", [16]byte{0x20, 0x01, 15: 9}, [16]byte{0x20, 0x01, 15: 8}, 17, 0},
|
|
||||||
{"max-u16-len", ones(0xff), ones(0xfe), 6, 65535},
|
|
||||||
{"len-past-u16", ones(0xff), ones(0xff), 17, 0x12345}, // exercises the 32-bit split
|
|
||||||
}
|
|
||||||
for _, c := range cases {
|
|
||||||
t.Run(c.name, func(t *testing.T) {
|
|
||||||
// RFC 8200 pseudo-header: src(16) dst(16) len(4) zero(3) next(1).
|
|
||||||
ph := make([]byte, 40)
|
|
||||||
copy(ph[0:16], c.src[:])
|
|
||||||
copy(ph[16:32], c.dst[:])
|
|
||||||
binary.BigEndian.PutUint32(ph[32:36], uint32(c.l4Len))
|
|
||||||
ph[39] = c.proto
|
|
||||||
want := refFold(refSum(ph))
|
|
||||||
|
|
||||||
got := foldOnceNoInvert(pseudoSumIPv6(c.src[:], c.dst[:], c.proto, c.l4Len))
|
|
||||||
if got != want {
|
|
||||||
t.Errorf("fold(pseudoSumIPv6) = %#x, want %#x", got, want)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestIPv4HdrChecksumMatchesReference(t *testing.T) {
|
|
||||||
rng := rand.New(rand.NewSource(0x1791))
|
|
||||||
for _, hdrLen := range []int{20, 24, 40, 60} {
|
|
||||||
for trial := range 200 {
|
|
||||||
hdr := make([]byte, hdrLen)
|
|
||||||
rng.Read(hdr)
|
|
||||||
hdr[0] = 0x40 | byte(hdrLen/4)
|
|
||||||
hdr[10], hdr[11] = 0, 0 // checksum field zeroed, as the contract requires
|
|
||||||
|
|
||||||
want := ^refFold(refSum(hdr))
|
|
||||||
got := ipv4HdrChecksum(hdr)
|
|
||||||
if got != want {
|
|
||||||
t.Fatalf("ipv4HdrChecksum(len=%d trial=%d) = %#x, want %#x", hdrLen, trial, got, want)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Receiver-side property: with the checksum stored, the full
|
|
||||||
// header must sum to all-ones.
|
|
||||||
binary.BigEndian.PutUint16(hdr[10:12], got)
|
|
||||||
if v := refFold(refSum(hdr)); v != 0xffff {
|
|
||||||
t.Fatalf("stored checksum does not validate: full-header fold = %#x", v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TestChecksumSeedReceiverAcceptance is the end-to-end property the helpers
|
|
||||||
// exist for: seed the TCP checksum field with fold(pseudoSum), do what the
|
|
||||||
// kernel's NEEDS_CSUM completion does (one's-complement sum over the L4
|
|
||||||
// bytes including the seed, then invert, then store), and verify the result
|
|
||||||
// the way a receiver does (pseudo-header + L4 must sum to all-ones).
|
|
||||||
func TestChecksumSeedReceiverAcceptance(t *testing.T) {
|
|
||||||
rng := rand.New(rand.NewSource(0x1826))
|
|
||||||
for trial := range 200 {
|
|
||||||
src := [4]byte{byte(rng.Intn(256)), byte(rng.Intn(256)), byte(rng.Intn(256)), byte(rng.Intn(256))}
|
|
||||||
dst := [4]byte{byte(rng.Intn(256)), byte(rng.Intn(256)), byte(rng.Intn(256)), byte(rng.Intn(256))}
|
|
||||||
payLen := rng.Intn(1500)
|
|
||||||
l4 := make([]byte, 20+payLen)
|
|
||||||
rng.Read(l4)
|
|
||||||
|
|
||||||
// Seed exactly as flushSlot does.
|
|
||||||
seed := foldOnceNoInvert(pseudoSumIPv4(src[:], dst[:], 6, len(l4)))
|
|
||||||
binary.BigEndian.PutUint16(l4[16:18], seed)
|
|
||||||
|
|
||||||
// Kernel NEEDS_CSUM completion: sum the L4 region (seed included,
|
|
||||||
// which is equivalent to summing with the field zeroed and folding
|
|
||||||
// the seed in), invert, store.
|
|
||||||
final := ^refFold(refSum(l4[:16]) + uint64(seed) + refSum(l4[18:]))
|
|
||||||
binary.BigEndian.PutUint16(l4[16:18], final)
|
|
||||||
|
|
||||||
// Receiver validation.
|
|
||||||
ph := make([]byte, 12)
|
|
||||||
copy(ph[0:4], src[:])
|
|
||||||
copy(ph[4:8], dst[:])
|
|
||||||
ph[9] = 6
|
|
||||||
binary.BigEndian.PutUint16(ph[10:12], uint16(len(l4)))
|
|
||||||
if v := refFold(refSum(ph) + refSum(l4)); v != 0xffff {
|
|
||||||
t.Fatalf("trial %d: receiver rejects packet: fold = %#x (seed=%#x final=%#x payLen=%d)",
|
|
||||||
trial, v, seed, final, payLen)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,169 +0,0 @@
|
|||||||
package batch
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
|
||||||
)
|
|
||||||
|
|
||||||
// SortKey identifies a packet's position in its sender's transmission order.
|
|
||||||
type SortKey struct {
|
|
||||||
// Epoch is a receiver-local ordinal for the tunnel (ConnectionState) that decrypted the packet:
|
|
||||||
// a re-handshake replaces the tunnel outright and the replacement's epoch is higher,
|
|
||||||
// so the old tunnel's packets sort first during the cutover overlap.
|
|
||||||
Epoch uint64
|
|
||||||
// Counter is the packet's AEAD message counter within that tunnel.
|
|
||||||
Counter uint64
|
|
||||||
}
|
|
||||||
|
|
||||||
// flowKey identifies a transport flow by {src, dst, sport, dport, family}.
|
|
||||||
// Comparable, so map lookups and linear scans over the slot list stay tight.
|
|
||||||
// Shared by the TCP and UDP coalescers; each coalescer keeps its own
|
|
||||||
// openSlots map, so a TCP and UDP flow on the same 5-tuple-without-proto never alias.
|
|
||||||
type flowKey struct {
|
|
||||||
src, dst [16]byte
|
|
||||||
sport, dport uint16
|
|
||||||
isV6 bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// initialSlots is the starting capacity of the slot pool.
|
|
||||||
// One flow per packet is the worst case, so this matches a typical carrier-side recvmmsg batch on the UDP socket.
|
|
||||||
const initialSlots = 64
|
|
||||||
|
|
||||||
// parseIPAt validates the IP header for lane parsing. newPacket already resolved the L4 protocol
|
|
||||||
// and offset for the firewall, so there is no proto sniff here; the caller's ipHdrLen is
|
|
||||||
// cross-checked instead. A plain header (v4 IHL 20, v6 exactly 40) is the only coalesceable
|
|
||||||
// shape. The v6 check is load-bearing: it rejects extension-header packets whose L4 is not at byte 40.
|
|
||||||
//
|
|
||||||
// The prologues fill fk's addresses and family in place (ports belong to the L4 parser; fk must
|
|
||||||
// be zero on entry so the v4 path leaves src[4:]/dst[4:] clear for map equality) and return pkt
|
|
||||||
// trimmed to the IP-declared length. The receiver-as-out-pointer shape is deliberate: these
|
|
||||||
// functions are too big to inline, and returning structs by value put five 64-byte copies on the
|
|
||||||
// per-packet path.
|
|
||||||
func (fk *flowKey) parseIPAt(pkt []byte, ipHdrLen int) ([]byte, bool) {
|
|
||||||
if len(pkt) < 20 {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
switch pkt[0] >> 4 {
|
|
||||||
case 4:
|
|
||||||
if ipHdrLen != 20 {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
return fk.parseIPv4Prologue(pkt)
|
|
||||||
case 6:
|
|
||||||
if ipHdrLen != 40 || len(pkt) < 40 {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
return fk.parseIPv6Prologue(pkt)
|
|
||||||
}
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseIPv4Prologue is the shared IPv4 tail of the prologue entries; the caller has verified
|
|
||||||
// len(pkt) >= 20 and the version.
|
|
||||||
func (fk *flowKey) parseIPv4Prologue(pkt []byte) ([]byte, bool) {
|
|
||||||
ihl := int(pkt[0]&0x0f) * 4
|
|
||||||
if ihl != 20 {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
// Reject any fragmentation (MF or nonzero offset). The dispatcher already gated FragAny; kept
|
|
||||||
// as defense in depth, since a fragment folded into a superpacket would corrupt reassembly.
|
|
||||||
if binary.BigEndian.Uint16(pkt[6:8])&0x3fff != 0 {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
totalLen := int(binary.BigEndian.Uint16(pkt[2:4]))
|
|
||||||
if totalLen > len(pkt) || totalLen < ihl {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
fk.isV6 = false
|
|
||||||
copy(fk.src[:4], pkt[12:16])
|
|
||||||
copy(fk.dst[:4], pkt[16:20])
|
|
||||||
return pkt[:totalLen], true
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseIPv6Prologue is the shared IPv6 tail; the caller has verified len(pkt) >= 40, the version,
|
|
||||||
// and that the L4 header sits at byte 40.
|
|
||||||
func (fk *flowKey) parseIPv6Prologue(pkt []byte) ([]byte, bool) {
|
|
||||||
payloadLen := int(binary.BigEndian.Uint16(pkt[4:6]))
|
|
||||||
if 40+payloadLen > len(pkt) {
|
|
||||||
return nil, false
|
|
||||||
}
|
|
||||||
fk.isV6 = true
|
|
||||||
copy(fk.src[:], pkt[8:24])
|
|
||||||
copy(fk.dst[:], pkt[24:40])
|
|
||||||
return pkt[:40+payloadLen], true
|
|
||||||
}
|
|
||||||
|
|
||||||
// ipHeadersMatch compares the IP portion of two packet header prefixes for
|
|
||||||
// byte-for-byte equality on every field that must be identical across coalesced segments.
|
|
||||||
// Size/IPID/IPCsum are masked out.
|
|
||||||
// The full DSCP/ECN byte (IPv4 ToS / IPv6 traffic class) is compared, matching Linux kernel GRO:
|
|
||||||
// segments with differing ECN codepoints must not coalesce,
|
|
||||||
// otherwise ORing e.g. ECT(0) with ECT(1) would fabricate a false CE (congestion) mark or mark a Not-ECT flow as ECN-capable.
|
|
||||||
//
|
|
||||||
// The transport (L4) portion of the header is checked separately by the per-protocol matcher.
|
|
||||||
func ipHeadersMatch(a, b []byte, isV6 bool) bool {
|
|
||||||
if isV6 {
|
|
||||||
// IPv6: [0:4] = version/TC/flow label (TC[1:0] is ECN, so the full TC byte must match),
|
|
||||||
// [6:40] = next_hdr/hop + src + dst. Skip [4:6] payload_len.
|
|
||||||
return bytes.Equal(a[:4], b[:4]) && bytes.Equal(a[6:40], b[6:40])
|
|
||||||
}
|
|
||||||
// IPv4: [0:2] = version/IHL + DSCP|ECN (full ECN byte must match),
|
|
||||||
// [6:10] = flags/fragoff/TTL/proto, [12:20] = src+dst.
|
|
||||||
// Skip [2:4] total len, [4:6] id, [10:12] csum.
|
|
||||||
return bytes.Equal(a[:2], b[:2]) && bytes.Equal(a[6:10], b[6:10]) && bytes.Equal(a[12:20], b[12:20])
|
|
||||||
}
|
|
||||||
|
|
||||||
// ipv4FlagDF is the Don't Fragment bit in the IPv4 flags byte (header byte 6).
|
|
||||||
const ipv4FlagDF = 0x40
|
|
||||||
|
|
||||||
// ipv4CanCoalesceID reports whether an IPv4 packet whose header starts at
|
|
||||||
// nextHdr may join a chain whose seed header is seedHdr as segment index seg
|
|
||||||
// (the seed is segment 0). Kernel GSO re-stamps outgoing segment IDs as
|
|
||||||
// seed_id+n, so coalescing is only transparent when that re-stamp is either
|
|
||||||
// harmless (DF set: RFC 6864 atomic datagrams, the ID carries no meaning) or
|
|
||||||
// reproduces the original IDs exactly (DF clear + IDs already sequential —
|
|
||||||
// the same admission rule kernel GRO applies). Without this, a DF=0 sender
|
|
||||||
// with non-sequential IDs (e.g. OpenBSD's randomized IDs) could have IDs
|
|
||||||
// rewritten into ranges that collide across superpackets, corrupting
|
|
||||||
// reassembly if the packets are fragmented after the TUN write.
|
|
||||||
//
|
|
||||||
// DF itself is guaranteed uniform across a chain by ipHeadersMatch (byte 6
|
|
||||||
// is inside its compared range), so checking the seed's copy suffices.
|
|
||||||
func ipv4CanCoalesceID(seedHdr, nextHdr []byte, seg int) bool {
|
|
||||||
if seedHdr[6]&ipv4FlagDF != 0 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
expect := binary.BigEndian.Uint16(seedHdr[4:6]) + uint16(seg)
|
|
||||||
return binary.BigEndian.Uint16(nextHdr[4:6]) == expect
|
|
||||||
}
|
|
||||||
|
|
||||||
// Arena is an injectable byte-slab that hands out non-overlapping borrowed
|
|
||||||
// slices via Reserve and releases them in bulk via Reset.
|
|
||||||
type Arena struct {
|
|
||||||
buf []byte
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewArena returns an Arena with a pre-allocated backing of the given capacity.
|
|
||||||
func NewArena(capacity int) *Arena {
|
|
||||||
return &Arena{buf: make([]byte, 0, capacity)}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Reserve hands out a non-overlapping sz-byte slice from the arena.
|
|
||||||
// If the request doesn't fit the current backing, a fresh, larger backing is allocated.
|
|
||||||
// Already-borrowed slices reference the old backing and remain valid until Reset.
|
|
||||||
func (a *Arena) Reserve(sz int) []byte {
|
|
||||||
if len(a.buf)+sz > cap(a.buf) {
|
|
||||||
newCap := max(cap(a.buf)*2, sz)
|
|
||||||
a.buf = make([]byte, 0, newCap)
|
|
||||||
}
|
|
||||||
start := len(a.buf)
|
|
||||||
a.buf = a.buf[:start+sz]
|
|
||||||
return a.buf[start : start+sz : start+sz]
|
|
||||||
}
|
|
||||||
|
|
||||||
// Reset releases every slice handed out since the last Reset.
|
|
||||||
// Callers must not use any previously-borrowed slice after this returns.
|
|
||||||
// The underlying backing array is retained so subsequent Reserves don't re-allocate.
|
|
||||||
func (a *Arena) Reset() {
|
|
||||||
a.buf = a.buf[:0]
|
|
||||||
}
|
|
||||||
Loaded 100 of 205 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user