mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 21:36:52 +01:00
Compare commits
57
Commits
v1.11.2
...
pq-handshake
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b3a252e64d | ||
|
|
13658b74a0 | ||
|
|
22cdb0739a | ||
|
|
45e449a591 | ||
|
|
a36ce25af4 | ||
|
|
2e5adfddc6 | ||
|
|
31f3d6435e | ||
|
|
8f9a631f6e | ||
|
|
8a2de9b1b5 | ||
|
|
a8c52f5c13 | ||
|
|
13af8dd6f3 | ||
|
|
5bb0622192 | ||
|
|
f3705cbb67 | ||
|
|
94be454f4f | ||
|
|
5f26c1a7e5 | ||
|
|
d47c8c71f1 | ||
|
|
f57539a163 | ||
|
|
8d8ae0f744 | ||
|
|
f9b0853476 | ||
|
|
d5062dacf0 | ||
|
|
7cfa47d569 | ||
|
|
e20569ce51 | ||
|
|
9651ffdb0d | ||
|
|
3a45c01656 | ||
|
|
019cc46a7f | ||
|
|
cf3f315cd3 | ||
|
|
3fc627e08d | ||
|
|
abff1a4555 | ||
|
|
227134a1d5 | ||
|
|
232bacfdd0 | ||
|
|
4e1ef9cd73 | ||
|
|
614e0ea3aa | ||
|
|
2999fc0b6a | ||
|
|
f474b534e1 | ||
|
|
0dc8a28d1f | ||
|
|
89178f45ba | ||
|
|
6a72e1c304 | ||
|
|
e50f8128f4 | ||
|
|
dd8f660c0a | ||
|
|
ec3304e3a9 | ||
|
|
aaa2ff7fff | ||
|
|
657f6ad044 | ||
|
|
19e04db115 | ||
|
|
9c5d701648 | ||
|
|
edc3c5e018 | ||
|
|
b8b159a486 | ||
|
|
49e35d1283 | ||
|
|
6fcb926334 | ||
|
|
28d82f7b8a | ||
|
|
f15d10fc54 | ||
|
|
bfe7790848 | ||
|
|
e7b4e094b9 | ||
|
|
6740518403 | ||
|
|
5cbf029d06 | ||
|
|
368855c2e8 | ||
|
|
6d124d0441 | ||
|
|
72bf111209 |
No files matched your search
@@ -43,8 +43,15 @@ runs:
|
|||||||
with:
|
with:
|
||||||
role-to-assume: ${{ inputs.role }}
|
role-to-assume: ${{ inputs.role }}
|
||||||
aws-region: ${{ inputs.region }}
|
aws-region: ${{ inputs.region }}
|
||||||
# Default is 12 retries to ride out IAM trust-policy propagation; once
|
# An STS secret key with special characters does not survive the
|
||||||
# the role is stable we want a real misconfiguration to fail fast.
|
# pwsh -> make -> MSYS sh -> aws.exe chain, and SigV4 then signs with a
|
||||||
|
# key that no longer matches, so the first S3 upload fails with
|
||||||
|
# SignatureDoesNotMatch. Retries the assume until it comes back clean.
|
||||||
|
# Same fix as DefinedNet/dnclient#867.
|
||||||
|
special-characters-workaround: true
|
||||||
|
# Overridden by the workaround above and kept for whenever that goes:
|
||||||
|
# the default 12 rides out IAM trust-policy propagation, and once the
|
||||||
|
# role is stable a real misconfiguration should fail fast.
|
||||||
retry-max-attempts: 5
|
retry-max-attempts: 5
|
||||||
|
|
||||||
- name: Sign .exe files
|
- name: Sign .exe files
|
||||||
|
|||||||
Executable
+142
@@ -0,0 +1,142 @@
|
|||||||
|
#!/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 -
|
||||||
@@ -73,8 +73,11 @@ jobs:
|
|||||||
build-darwin:
|
build-darwin:
|
||||||
name: Build Universal Darwin
|
name: Build Universal Darwin
|
||||||
env:
|
env:
|
||||||
HAS_SIGNING_CREDS: ${{ secrets.AC_USERNAME != '' }}
|
HAS_SIGNING_CREDS: ${{ secrets.APPLE_SIGNING_ROLE_ARN != '' }}
|
||||||
runs-on: macos-latest
|
runs-on: macos-latest
|
||||||
|
permissions:
|
||||||
|
id-token: write
|
||||||
|
contents: read
|
||||||
steps:
|
steps:
|
||||||
- uses: actions/checkout@v7
|
- uses: actions/checkout@v7
|
||||||
|
|
||||||
@@ -83,17 +86,68 @@ jobs:
|
|||||||
go-version: '1.26'
|
go-version: '1.26'
|
||||||
check-latest: true
|
check-latest: true
|
||||||
|
|
||||||
|
# GitHub holds ARNs, not credentials, and ARNs outlive a rotation
|
||||||
|
- name: Configure AWS credentials
|
||||||
|
if: env.HAS_SIGNING_CREDS == 'true'
|
||||||
|
uses: aws-actions/configure-aws-credentials@v6
|
||||||
|
with:
|
||||||
|
role-to-assume: ${{ secrets.APPLE_SIGNING_ROLE_ARN }}
|
||||||
|
aws-region: us-east-2
|
||||||
|
|
||||||
|
# parse-json-secrets unpacks into SIGNING_* and ASC_*, masked on the way in
|
||||||
|
- name: Fetch signing credentials
|
||||||
|
if: env.HAS_SIGNING_CREDS == 'true'
|
||||||
|
uses: aws-actions/aws-secretsmanager-get-secrets@v3
|
||||||
|
with:
|
||||||
|
parse-json-secrets: true
|
||||||
|
secret-ids: |
|
||||||
|
SIGNING,${{ secrets.APPLE_SIGNING_DEVELOPER_ID_ARN }}
|
||||||
|
ASC,${{ secrets.APPLE_NOTARY_KEY_ARN }}
|
||||||
|
|
||||||
- name: Import certificates
|
- name: Import certificates
|
||||||
if: env.HAS_SIGNING_CREDS == 'true'
|
if: env.HAS_SIGNING_CREDS == 'true'
|
||||||
uses: Apple-Actions/import-codesign-certs@v7
|
uses: Apple-Actions/import-codesign-certs@v7
|
||||||
with:
|
with:
|
||||||
p12-file-base64: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_P12_BASE64 }}
|
p12-file-base64: ${{ env.SIGNING_P12_BASE64 }}
|
||||||
p12-password: ${{ secrets.APPLE_DEVELOPER_CERTIFICATE_PASSWORD }}
|
p12-password: ${{ env.SIGNING_PASSWORD }}
|
||||||
|
|
||||||
|
# The action imports but does not check the chain validates, which is how a p12
|
||||||
|
# missing its intermediate reaches a failing codesign
|
||||||
|
- name: Check the identity is usable
|
||||||
|
if: env.HAS_SIGNING_CREDS == 'true'
|
||||||
|
run: |
|
||||||
|
: "${SIGNING_IDENTITY_SHA1:?empty, so the secret has no identity_sha1}"
|
||||||
|
identities=$(security find-identity -v -p codesigning signing_temp.keychain)
|
||||||
|
case "$identities" in
|
||||||
|
*"$SIGNING_IDENTITY_SHA1"*) ;;
|
||||||
|
*) printf '%s\n' "$identities" >&2; exit 1 ;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
# notarytool wants the key as a file
|
||||||
|
- name: Write the App Store Connect key
|
||||||
|
if: env.HAS_SIGNING_CREDS == 'true'
|
||||||
|
run: |
|
||||||
|
mkdir -p ~/private_keys
|
||||||
|
chmod 700 ~/private_keys
|
||||||
|
key_path="$HOME/private_keys/AuthKey_${ASC_KEY_ID}.p8"
|
||||||
|
(umask 077; printf '%s\n' "$ASC_PRIVATE_KEY" > "$key_path")
|
||||||
|
echo "ASC_P8=$key_path" >> "$GITHUB_ENV"
|
||||||
|
|
||||||
|
- name: Drop the credentials from the environment
|
||||||
|
if: env.HAS_SIGNING_CREDS == 'true'
|
||||||
|
run: |
|
||||||
|
# The action's own inventory, so a new field in a secret is covered
|
||||||
|
python3 -c '
|
||||||
|
import json, os
|
||||||
|
raw = os.environ.get("SECRETS_LIST_CLEAN_UP")
|
||||||
|
if raw is None and os.environ.get("SIGNING_P12_BASE64"):
|
||||||
|
raise SystemExit("SECRETS_LIST_CLEAN_UP is gone, fetched secrets are not being scrubbed")
|
||||||
|
keep = {"SIGNING_IDENTITY_SHA1", "ASC_KEY_ID", "ASC_ISSUER_ID"}
|
||||||
|
names = [n for n in json.loads(raw or "[]") if n not in keep]
|
||||||
|
print("\n".join(f"{n}=" for n in dict.fromkeys(names)))
|
||||||
|
' >> "$GITHUB_ENV"
|
||||||
|
|
||||||
- name: Build, sign, and notarize
|
- name: Build, sign, and notarize
|
||||||
env:
|
|
||||||
AC_USERNAME: ${{ secrets.AC_USERNAME }}
|
|
||||||
AC_PASSWORD: ${{ secrets.AC_PASSWORD }}
|
|
||||||
run: |
|
run: |
|
||||||
rm -rf release
|
rm -rf release
|
||||||
mkdir release
|
mkdir release
|
||||||
@@ -102,17 +156,34 @@ jobs:
|
|||||||
lipo -create -output ./release/nebula ./build/darwin-amd64/nebula ./build/darwin-arm64/nebula
|
lipo -create -output ./release/nebula ./build/darwin-amd64/nebula ./build/darwin-arm64/nebula
|
||||||
lipo -create -output ./release/nebula-cert ./build/darwin-amd64/nebula-cert ./build/darwin-arm64/nebula-cert
|
lipo -create -output ./release/nebula-cert ./build/darwin-amd64/nebula-cert ./build/darwin-arm64/nebula-cert
|
||||||
|
|
||||||
if [ -n "$AC_USERNAME" ]; then
|
# Unset in a fork, which has no credentials to sign with
|
||||||
codesign -s "10BC1FDDEB6CE753550156C0669109FAC49E4D1E" -f -v --timestamp --options=runtime -i "net.defined.nebula" ./release/nebula
|
if [ -n "$SIGNING_IDENTITY_SHA1" ]; then
|
||||||
codesign -s "10BC1FDDEB6CE753550156C0669109FAC49E4D1E" -f -v --timestamp --options=runtime -i "net.defined.nebula-cert" ./release/nebula-cert
|
codesign -s "$SIGNING_IDENTITY_SHA1" -f -v --timestamp --options=runtime -i "net.defined.nebula" ./release/nebula
|
||||||
|
codesign -s "$SIGNING_IDENTITY_SHA1" -f -v --timestamp --options=runtime -i "net.defined.nebula-cert" ./release/nebula-cert
|
||||||
fi
|
fi
|
||||||
|
|
||||||
zip -j release/nebula-darwin.zip release/nebula-cert release/nebula
|
zip -j release/nebula-darwin.zip release/nebula-cert release/nebula
|
||||||
|
|
||||||
if [ -n "$AC_USERNAME" ]; then
|
if [ -n "$ASC_P8" ]; then
|
||||||
xcrun notarytool submit ./release/nebula-darwin.zip --team-id "576H3XS7FP" --apple-id "$AC_USERNAME" --password "$AC_PASSWORD" --wait
|
xcrun notarytool submit ./release/nebula-darwin.zip --key "$ASC_P8" --key-id "$ASC_KEY_ID" --issuer "$ASC_ISSUER_ID" --wait
|
||||||
fi
|
fi
|
||||||
|
|
||||||
|
- name: Drop the signing key
|
||||||
|
if: always() && env.HAS_SIGNING_CREDS == 'true'
|
||||||
|
run: |
|
||||||
|
# Locked, not deleted: import-codesign-certs deletes it in its own post
|
||||||
|
# step and fails the job if it is already gone. Locked is unusable.
|
||||||
|
security lock-keychain signing_temp.keychain || true
|
||||||
|
rm -f "$ASC_P8"
|
||||||
|
# Nothing later in this job needs AWS
|
||||||
|
python3 -c '
|
||||||
|
import json, os
|
||||||
|
names = json.loads(os.environ.get("SECRETS_LIST_CLEAN_UP") or "[]")
|
||||||
|
names += ["ASC_P8", "SIGNING_IDENTITY_SHA1", "ASC_KEY_ID", "ASC_ISSUER_ID",
|
||||||
|
"AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN"]
|
||||||
|
print("\n".join(f"{n}=" for n in dict.fromkeys(names)))
|
||||||
|
' >> "$GITHUB_ENV"
|
||||||
|
|
||||||
- name: Upload artifacts
|
- name: Upload artifacts
|
||||||
uses: actions/upload-artifact@v7
|
uses: actions/upload-artifact@v7
|
||||||
with:
|
with:
|
||||||
|
|||||||
@@ -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@v3
|
- uses: Vampire/setup-wsl@v7
|
||||||
with:
|
with:
|
||||||
distribution: Ubuntu-24.04
|
distribution: Ubuntu-24.04
|
||||||
additional-packages: iputils-ping iproute2
|
additional-packages: iputils-ping iproute2
|
||||||
|
|||||||
+26
-25
@@ -25,39 +25,40 @@ jobs:
|
|||||||
go-version: '1.26'
|
go-version: '1.26'
|
||||||
check-latest: true
|
check-latest: true
|
||||||
|
|
||||||
- name: build
|
- name: Smoke Docker
|
||||||
run: make bin-docker CGO_ENABLED=1 BUILD_ARGS=-race
|
run: make smoke-docker
|
||||||
|
|
||||||
- name: setup docker image
|
- name: Smoke Docker IPv6 overlay
|
||||||
working-directory: ./.github/workflows/smoke
|
run: make smoke-docker-ipv6
|
||||||
run: ./build.sh
|
|
||||||
|
|
||||||
- name: run smoke
|
- name: Smoke Relay Docker
|
||||||
working-directory: ./.github/workflows/smoke
|
run: make smoke-relay-docker
|
||||||
run: ./smoke.sh
|
|
||||||
|
|
||||||
- name: setup docker image ipv6
|
- name: Smoke Docker boringcrypto
|
||||||
working-directory: ./.github/workflows/smoke
|
run: make boringcrypto smoke-docker
|
||||||
run: SMOKE_OVERLAY_IPV6=1 ./build.sh
|
|
||||||
|
|
||||||
- name: run smoke ipv6
|
- name: Smoke Docker fips140
|
||||||
working-directory: ./.github/workflows/smoke
|
run: make fips140-all GOALS=smoke-docker
|
||||||
run: SMOKE_OVERLAY_IPV6=1 ./smoke.sh
|
|
||||||
|
timeout-minutes: 10
|
||||||
|
|
||||||
|
smoke-self:
|
||||||
|
name: Run self traffic smoke test on macOS
|
||||||
|
runs-on: macos-latest
|
||||||
|
steps:
|
||||||
|
|
||||||
- name: setup relay docker image
|
- uses: actions/checkout@v7
|
||||||
working-directory: ./.github/workflows/smoke
|
|
||||||
run: ./build-relay.sh
|
|
||||||
|
|
||||||
- name: run smoke relay
|
- uses: actions/setup-go@v7
|
||||||
working-directory: ./.github/workflows/smoke
|
with:
|
||||||
run: ./smoke-relay.sh
|
go-version: '1.26'
|
||||||
|
check-latest: true
|
||||||
|
|
||||||
- name: setup docker image for P256
|
- name: build
|
||||||
working-directory: ./.github/workflows/smoke
|
run: make bin
|
||||||
run: NAME="smoke-p256" CURVE=P256 ./build.sh
|
|
||||||
|
|
||||||
- name: run smoke-p256
|
- name: run smoke-self
|
||||||
working-directory: ./.github/workflows/smoke
|
working-directory: ./.github/workflows/smoke
|
||||||
run: NAME="smoke-p256" ./smoke.sh
|
run: ./smoke-self.sh
|
||||||
|
|
||||||
timeout-minutes: 10
|
timeout-minutes: 10
|
||||||
Executable
+130
@@ -0,0 +1,130 @@
|
|||||||
|
#!/bin/bash
|
||||||
|
|
||||||
|
# A host must be able to reach its own overlay address. Where the kernel sends
|
||||||
|
# that traffic through the tun rather than over loopback, nebula sees it and
|
||||||
|
# hands it straight back (immediatelyForwardToSelf), and whether the kernel
|
||||||
|
# accepts what comes back is only answerable against a real kernel. Runs one
|
||||||
|
# nebula on this machine as root and aims every probe at its own address.
|
||||||
|
|
||||||
|
set -e -x
|
||||||
|
|
||||||
|
set -o pipefail
|
||||||
|
|
||||||
|
V4=192.0.2.1
|
||||||
|
V6=2001:db8::1
|
||||||
|
|
||||||
|
case "$(uname -s)" in
|
||||||
|
Darwin) TUN_DEV=utun ;;
|
||||||
|
*) TUN_DEV=tun0 ;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
ROOT="$(cd ../../.. && pwd)"
|
||||||
|
|
||||||
|
rm -rf build/self
|
||||||
|
mkdir -p build/self
|
||||||
|
cd build/self
|
||||||
|
|
||||||
|
cleanup() {
|
||||||
|
echo
|
||||||
|
echo " *** cleanup"
|
||||||
|
echo
|
||||||
|
|
||||||
|
set +e
|
||||||
|
if [ -n "$NEBULA_PID" ]
|
||||||
|
then
|
||||||
|
sudo kill "$NEBULA_PID"
|
||||||
|
fi
|
||||||
|
{ kill $(jobs -p); wait; } 2>/dev/null
|
||||||
|
sed 's/^/ [self] /' nebula.log
|
||||||
|
}
|
||||||
|
|
||||||
|
trap cleanup EXIT
|
||||||
|
|
||||||
|
# perl is on every platform this runs on; timeout(1) is not.
|
||||||
|
alarm() {
|
||||||
|
perl -e 'alarm shift; exec @ARGV' "$@"
|
||||||
|
}
|
||||||
|
|
||||||
|
RESULTS=""
|
||||||
|
FAILED=""
|
||||||
|
probe() {
|
||||||
|
local name="$1"
|
||||||
|
shift
|
||||||
|
if "$@"
|
||||||
|
then
|
||||||
|
RESULTS="$RESULTS $name=ok"
|
||||||
|
else
|
||||||
|
RESULTS="$RESULTS $name=FAIL"
|
||||||
|
FAILED="$FAILED $name"
|
||||||
|
fi
|
||||||
|
}
|
||||||
|
|
||||||
|
# Send one datagram, then wait for the listener to have written it out.
|
||||||
|
udp_probe() {
|
||||||
|
echo self | alarm 5 nc -u -w1 "$1" 3000 || true
|
||||||
|
set +x
|
||||||
|
for _ in $(seq 1 20)
|
||||||
|
do
|
||||||
|
if grep -q self "$2"
|
||||||
|
then
|
||||||
|
set -x
|
||||||
|
return 0
|
||||||
|
fi
|
||||||
|
sleep 0.25
|
||||||
|
done
|
||||||
|
set -x
|
||||||
|
return 1
|
||||||
|
}
|
||||||
|
|
||||||
|
"$ROOT/nebula-cert" ca -name "Smoke Test"
|
||||||
|
"$ROOT/nebula-cert" sign -name self -networks "$V4/24,$V6/64"
|
||||||
|
|
||||||
|
HOST=self AM_LIGHTHOUSE=true TUN_DEV="$TUN_DEV" ../../genconfig.sh >self.yml
|
||||||
|
|
||||||
|
"$ROOT/nebula" -config self.yml -test
|
||||||
|
|
||||||
|
sudo -v
|
||||||
|
sudo "$ROOT/nebula" -config self.yml >nebula.log 2>&1 &
|
||||||
|
NEBULA_PID=$!
|
||||||
|
|
||||||
|
for _ in $(seq 1 40)
|
||||||
|
do
|
||||||
|
ifconfig | grep "inet6 $V6 " >/dev/null && break
|
||||||
|
sleep 0.25
|
||||||
|
done
|
||||||
|
ifconfig | grep "inet $V4 "
|
||||||
|
ifconfig | grep "inet6 $V6 "
|
||||||
|
|
||||||
|
nc -l "$V4" 2000 >/dev/null &
|
||||||
|
nc -l "$V6" 2000 >/dev/null &
|
||||||
|
nc -u -l "$V4" 3000 >udp4.txt &
|
||||||
|
nc -u -l "$V6" 3000 >udp6.txt &
|
||||||
|
sleep 1
|
||||||
|
|
||||||
|
set +x
|
||||||
|
echo
|
||||||
|
echo " *** Testing self traffic from $V4"
|
||||||
|
echo
|
||||||
|
set -x
|
||||||
|
probe icmp4 alarm 5 ping -c1 "$V4"
|
||||||
|
probe tcp4 alarm 5 nc -z "$V4" 2000
|
||||||
|
probe udp4 udp_probe "$V4" udp4.txt
|
||||||
|
|
||||||
|
set +x
|
||||||
|
echo
|
||||||
|
echo " *** Testing self traffic from $V6"
|
||||||
|
echo
|
||||||
|
set -x
|
||||||
|
probe icmp6 alarm 5 ping6 -c1 "$V6"
|
||||||
|
probe tcp6 alarm 5 nc -z "$V6" 2000
|
||||||
|
probe udp6 udp_probe "$V6" udp6.txt
|
||||||
|
|
||||||
|
set +x
|
||||||
|
echo
|
||||||
|
echo " *** self traffic:$RESULTS"
|
||||||
|
echo
|
||||||
|
if [ -n "$FAILED" ]
|
||||||
|
then
|
||||||
|
echo "self traffic failed:$FAILED" >&2
|
||||||
|
exit 1
|
||||||
|
fi
|
||||||
@@ -51,15 +51,19 @@ wsl -d $Distro -- bash -c "rm -rf $WslDir && mkdir -p $WslDir" | Out-Null
|
|||||||
$DevName = 'nebula-smoke'
|
$DevName = 'nebula-smoke'
|
||||||
$Ip1 = '192.168.241.1'
|
$Ip1 = '192.168.241.1'
|
||||||
$Ip2 = '192.168.241.2'
|
$Ip2 = '192.168.241.2'
|
||||||
|
# Dual stack on purpose: a v4-only overlay never exercises the v6 side of tun.mtu.
|
||||||
|
$Ip6_1 = 'fd42:4242:241::1'
|
||||||
|
$Ip6_2 = 'fd42:4242:241::2'
|
||||||
|
$Mtu = 1300
|
||||||
$Port = 4242
|
$Port = 4242
|
||||||
|
|
||||||
& $NebulaCert ca -name 'smoke-ca' -out-crt "$WorkDir\ca.crt" -out-key "$WorkDir\ca.key"
|
& $NebulaCert ca -name 'smoke-ca' -out-crt "$WorkDir\ca.crt" -out-key "$WorkDir\ca.key"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "nebula-cert ca failed (exit $LASTEXITCODE)" }
|
if ($LASTEXITCODE -ne 0) { throw "nebula-cert ca failed (exit $LASTEXITCODE)" }
|
||||||
|
|
||||||
& $NebulaCert sign -name 'lighthouse' -networks "$Ip1/24" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\lighthouse.crt" -out-key "$WorkDir\lighthouse.key"
|
& $NebulaCert sign -name 'lighthouse' -networks "$Ip1/24,$Ip6_1/64" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\lighthouse.crt" -out-key "$WorkDir\lighthouse.key"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign lighthouse failed (exit $LASTEXITCODE)" }
|
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign lighthouse failed (exit $LASTEXITCODE)" }
|
||||||
|
|
||||||
& $NebulaCert sign -name 'peer' -networks "$Ip2/24" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\peer.crt" -out-key "$WorkDir\peer.key"
|
& $NebulaCert sign -name 'peer' -networks "$Ip2/24,$Ip6_2/64" -ca-crt "$WorkDir\ca.crt" -ca-key "$WorkDir\ca.key" -out-crt "$WorkDir\peer.crt" -out-key "$WorkDir\peer.key"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign peer failed (exit $LASTEXITCODE)" }
|
if ($LASTEXITCODE -ne 0) { throw "nebula-cert sign peer failed (exit $LASTEXITCODE)" }
|
||||||
|
|
||||||
# Windows lighthouse config.
|
# Windows lighthouse config.
|
||||||
@@ -82,7 +86,7 @@ tun:
|
|||||||
drop_local_broadcast: false
|
drop_local_broadcast: false
|
||||||
drop_multicast: false
|
drop_multicast: false
|
||||||
tx_queue: 500
|
tx_queue: 500
|
||||||
mtu: 1300
|
mtu: $Mtu
|
||||||
network_category: private
|
network_category: private
|
||||||
logging:
|
logging:
|
||||||
level: info
|
level: info
|
||||||
@@ -126,7 +130,7 @@ tun:
|
|||||||
drop_local_broadcast: false
|
drop_local_broadcast: false
|
||||||
drop_multicast: false
|
drop_multicast: false
|
||||||
tx_queue: 500
|
tx_queue: 500
|
||||||
mtu: 1300
|
mtu: $Mtu
|
||||||
logging:
|
logging:
|
||||||
level: info
|
level: info
|
||||||
format: text
|
format: text
|
||||||
@@ -169,7 +173,7 @@ Write-Host '=== WSL diagnostic ==='
|
|||||||
wsl --version 2>&1 | Out-Host
|
wsl --version 2>&1 | Out-Host
|
||||||
wsl --list --verbose 2>&1 | Out-Host
|
wsl --list --verbose 2>&1 | Out-Host
|
||||||
wsl -d $Distro -u root -- uname -a | Out-Host
|
wsl -d $Distro -u root -- uname -a | Out-Host
|
||||||
wsl -d $Distro -u root -- bash -c "modprobe tun 2>&1 || true; mkdir -p /dev/net; [ -c /dev/net/tun ] || mknod /dev/net/tun c 10 200; chmod 600 /dev/net/tun; ls -l /dev/net/tun"
|
wsl -d $Distro -u root -- bash -c "modprobe tun 2>&1 || true; mkdir -p /dev/net; [ -c /dev/net/tun ] || mknod /dev/net/tun c 10 200; chmod 600 /dev/net/tun; { echo 0 > /proc/sys/net/ipv6/conf/all/disable_ipv6; echo 0 > /proc/sys/net/ipv6/conf/default/disable_ipv6; } 2>/dev/null || true; ls -l /dev/net/tun"
|
||||||
if ($LASTEXITCODE -ne 0) { throw "failed to prepare /dev/net/tun in WSL (TUN support missing?)" }
|
if ($LASTEXITCODE -ne 0) { throw "failed to prepare /dev/net/tun in WSL (TUN support missing?)" }
|
||||||
|
|
||||||
# Deliberately no New-NetFirewallRule calls here -- nebula's windows_bypass_wdf
|
# Deliberately no New-NetFirewallRule calls here -- nebula's windows_bypass_wdf
|
||||||
@@ -214,6 +218,16 @@ try {
|
|||||||
}
|
}
|
||||||
Write-Host "OK: $DevName NetworkCategory=Private"
|
Write-Host "OK: $DevName NetworkCategory=Private"
|
||||||
|
|
||||||
|
# v6 silently kept the adapter default of 65535 while v4 was correct.
|
||||||
|
foreach ($family in @('IPv4', 'IPv6')) {
|
||||||
|
Wait-Until -TimeoutSec 30 -What "$DevName $family NlMtu=$Mtu" -Predicate {
|
||||||
|
if ($lhProc.HasExited) { throw "lighthouse exited (code $($lhProc.ExitCode)) before $family mtu was set" }
|
||||||
|
$rows = @(Get-NetIPInterface -InterfaceAlias $DevName -AddressFamily $family -ErrorAction SilentlyContinue)
|
||||||
|
$rows.Count -gt 0 -and -not ($rows | Where-Object { $_.NlMtu -ne $Mtu })
|
||||||
|
}
|
||||||
|
Write-Host "OK: $DevName $family NlMtu=$Mtu"
|
||||||
|
}
|
||||||
|
|
||||||
Wait-Until -TimeoutSec 30 -What "WSL nebula1 with $Ip2" -Predicate {
|
Wait-Until -TimeoutSec 30 -What "WSL nebula1 with $Ip2" -Predicate {
|
||||||
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before tun was ready" }
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before tun was ready" }
|
||||||
$r = wsl -d $Distro -u root -- bash -c "ip -o addr show nebula1 2>/dev/null | grep -q 'inet $Ip2' && echo yes"
|
$r = wsl -d $Distro -u root -- bash -c "ip -o addr show nebula1 2>/dev/null | grep -q 'inet $Ip2' && echo yes"
|
||||||
@@ -221,6 +235,13 @@ try {
|
|||||||
}
|
}
|
||||||
Write-Host "OK: WSL nebula1 has $Ip2"
|
Write-Host "OK: WSL nebula1 has $Ip2"
|
||||||
|
|
||||||
|
Wait-Until -TimeoutSec 30 -What "WSL nebula1 with $Ip6_2" -Predicate {
|
||||||
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before the v6 address was up" }
|
||||||
|
$r = wsl -d $Distro -u root -- bash -c "ip -o addr show nebula1 2>/dev/null | grep -q 'inet6 $Ip6_2' && echo yes"
|
||||||
|
("$r").Trim() -eq 'yes'
|
||||||
|
}
|
||||||
|
Write-Host "OK: WSL nebula1 has $Ip6_2"
|
||||||
|
|
||||||
Wait-Until -TimeoutSec 30 -What "ping from WSL peer to windows lighthouse ($Ip1)" -Predicate {
|
Wait-Until -TimeoutSec 30 -What "ping from WSL peer to windows lighthouse ($Ip1)" -Predicate {
|
||||||
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before ping succeeded" }
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before ping succeeded" }
|
||||||
$r = wsl -d $Distro -u root -- bash -c "ping -c1 -W1 $Ip1 >/dev/null 2>&1 && echo OK"
|
$r = wsl -d $Distro -u root -- bash -c "ping -c1 -W1 $Ip1 >/dev/null 2>&1 && echo OK"
|
||||||
@@ -234,6 +255,28 @@ try {
|
|||||||
}
|
}
|
||||||
Write-Host "OK: windows lighthouse -> WSL peer"
|
Write-Host "OK: windows lighthouse -> WSL peer"
|
||||||
|
|
||||||
|
# Otherwise the v6 networks only prove the interface exists, not that it forwards.
|
||||||
|
Wait-Until -TimeoutSec 30 -What "v6 ping from WSL peer to windows lighthouse ($Ip6_1)" -Predicate {
|
||||||
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before the v6 ping succeeded" }
|
||||||
|
$r = wsl -d $Distro -u root -- bash -c "ping -6 -c1 -W1 $Ip6_1 >/dev/null 2>&1 && echo OK"
|
||||||
|
("$r").Trim() -eq 'OK'
|
||||||
|
}
|
||||||
|
Write-Host "OK: WSL peer -> windows lighthouse over v6"
|
||||||
|
|
||||||
|
# The NlMtu check above proves the value was written, not that windows honors it. A payload this size only
|
||||||
|
# crosses the tunnel as fragments cut at NlMtu on the way out of the adapter. Left at the adapter default it
|
||||||
|
# reaches nebula whole, overflows the udp.MTU (9001) write buffer and is dropped, so the ping never answers.
|
||||||
|
# Anything smaller would ride out as one oversized datagram and survive on IP fragmentation of the underlay.
|
||||||
|
$BigPayload = 9000
|
||||||
|
foreach ($target in @(@{ Family = 'v4'; Ip = $Ip2 }, @{ Family = 'v6'; Ip = $Ip6_2 })) {
|
||||||
|
Wait-Until -TimeoutSec 30 -What "$($target.Family) ping with a $BigPayload byte payload from windows lighthouse to WSL peer ($($target.Ip))" -Predicate {
|
||||||
|
if ($peerProc.HasExited) { throw "peer exited (code $($peerProc.ExitCode)) before the large $($target.Family) ping succeeded" }
|
||||||
|
$null = & ping.exe -n 1 -w 1000 -l $BigPayload $target.Ip
|
||||||
|
$LASTEXITCODE -eq 0
|
||||||
|
}
|
||||||
|
Write-Host "OK: windows lighthouse -> WSL peer, $BigPayload byte $($target.Family) payload"
|
||||||
|
}
|
||||||
|
|
||||||
Write-Host ''
|
Write-Host ''
|
||||||
Write-Host 'All smoke checks passed.'
|
Write-Host 'All smoke checks passed.'
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -58,9 +58,14 @@ jobs:
|
|||||||
e2e-cmd: make e2evv
|
e2e-cmd: make e2evv
|
||||||
- name: linux-boringcrypto
|
- name: linux-boringcrypto
|
||||||
os: ubuntu-latest
|
os: ubuntu-latest
|
||||||
build-cmd: make bin-boringcrypto
|
build-cmd: make boringcrypto
|
||||||
test-cmd: make test-boringcrypto
|
test-cmd: make boringcrypto test
|
||||||
e2e-cmd: make e2e GOEXPERIMENT=boringcrypto CGO_ENABLED=1 TEST_ENV="TEST_LOGS=1" TEST_FLAGS="-v -ldflags -checklinkname=0"
|
e2e-cmd: make boringcrypto e2evv
|
||||||
|
- 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
|
||||||
|
|||||||
+35
-1
@@ -7,6 +7,38 @@ 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
|
||||||
|
|
||||||
|
See the [v1.11.1](https://github.com/slackhq/nebula/milestone/30?closed=1) milestone for a complete list of changes.
|
||||||
|
|
||||||
|
### Changed
|
||||||
|
|
||||||
|
- IPv6 packets whose next header is a protocol Nebula does not parse (SCTP, GRE, IP-in-IP, etc.) are now
|
||||||
|
classified as that protocol with no ports, closing a firewall bypass where a crafted payload could steer
|
||||||
|
the classifier into reading one as TCP/UDP and matching a TCP/UDP rule. These packets are now matched as
|
||||||
|
their true protocol, so only a `proto: any` rule allows them. If you carry one of these protocols over the
|
||||||
|
overlay, confirm a `proto: any` rule covers it before upgrading, it may have been passing only through this
|
||||||
|
bypass. (#1840)
|
||||||
|
- Drop the dependency on `github.com/cyberdelia/go-metrics-graphite`, which has been unmaintained for over ten
|
||||||
|
years, by inlining the small amount of code Nebula used. (#1832)
|
||||||
|
|
||||||
|
### Fixed
|
||||||
|
|
||||||
|
- The ICMPv6 type was read from the wrong byte when classifying IPv6 packets, so the echo identifier used
|
||||||
|
for conntrack was never picked up. (#1840)
|
||||||
|
- Enforce outbound message counter limits so a tunnel is rehandshaked before the counter can wrap, preventing
|
||||||
|
nonce reuse. This is unreachable in practice, but is enforced as a defense-in-depth measure. (#1841)
|
||||||
|
- Prevent `nebula-cert ca` from running out of memory on 32bit systems when generating encrypted private keys. (#1834)
|
||||||
|
- Tolerate `ErrDumpInterrupted` when listing tun addresses on Linux, so a transient interrupted netlink dump
|
||||||
|
no longer aborts startup. (#1835)
|
||||||
|
|
||||||
## [1.11.0] - 2026-07-23
|
## [1.11.0] - 2026-07-23
|
||||||
|
|
||||||
See the [v1.11.0](https://github.com/slackhq/nebula/milestone/25?closed=1) milestone for a complete list of changes.
|
See the [v1.11.0](https://github.com/slackhq/nebula/milestone/25?closed=1) milestone for a complete list of changes.
|
||||||
@@ -870,7 +902,9 @@ created.)
|
|||||||
|
|
||||||
- Initial public release.
|
- Initial public release.
|
||||||
|
|
||||||
[Unreleased]: https://github.com/slackhq/nebula/compare/v1.10.3...HEAD
|
[Unreleased]: https://github.com/slackhq/nebula/compare/v1.11.1...HEAD
|
||||||
|
[1.11.1]: https://github.com/slackhq/nebula/releases/tag/v1.11.1
|
||||||
|
[1.11.0]: https://github.com/slackhq/nebula/releases/tag/v1.11.0
|
||||||
[1.10.3]: https://github.com/slackhq/nebula/releases/tag/v1.10.3
|
[1.10.3]: https://github.com/slackhq/nebula/releases/tag/v1.10.3
|
||||||
[1.10.2]: https://github.com/slackhq/nebula/releases/tag/v1.10.2
|
[1.10.2]: https://github.com/slackhq/nebula/releases/tag/v1.10.2
|
||||||
[1.10.1]: https://github.com/slackhq/nebula/releases/tag/v1.10.1
|
[1.10.1]: https://github.com/slackhq/nebula/releases/tag/v1.10.1
|
||||||
|
|||||||
@@ -72,6 +72,17 @@ 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
|
||||||
|
|
||||||
@@ -137,6 +148,8 @@ 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
|
||||||
@@ -157,17 +170,24 @@ 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:
|
||||||
go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula${NEBULA_CMD_SUFFIX} ${NEBULA_CMD_PATH}
|
$(GOENV) go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula${NEBULA_CMD_SUFFIX} ${NEBULA_CMD_PATH}
|
||||||
go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula-cert${NEBULA_CMD_SUFFIX} ./cmd/nebula-cert
|
$(GOENV) go build $(BUILD_ARGS) -ldflags "$(LDFLAGS)" -o ./nebula-cert${NEBULA_CMD_SUFFIX} ./cmd/nebula-cert
|
||||||
|
|
||||||
install:
|
install:
|
||||||
go install $(BUILD_ARGS) -ldflags "$(LDFLAGS)" ${NEBULA_CMD_PATH}
|
$(GOENV) go install $(BUILD_ARGS) -ldflags "$(LDFLAGS)" ${NEBULA_CMD_PATH}
|
||||||
go install $(BUILD_ARGS) -ldflags "$(LDFLAGS)" ./cmd/nebula-cert
|
$(GOENV) 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 -, ,$*))
|
||||||
@@ -178,8 +198,11 @@ 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
|
|
||||||
build/linux-arm64-boringcrypto/%: LDFLAGS += -checklinkname=0
|
# fips140
|
||||||
|
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 -, , $*)) \
|
||||||
@@ -210,10 +233,7 @@ vet:
|
|||||||
go vet $(VET_FLAGS) -v ./...
|
go vet $(VET_FLAGS) -v ./...
|
||||||
|
|
||||||
test:
|
test:
|
||||||
go test -v ./...
|
$(TEST_ENV) go test $(TEST_FLAGS) -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 ./...
|
||||||
@@ -222,11 +242,14 @@ test-cov-html:
|
|||||||
go test -coverprofile=coverage.out
|
go test -coverprofile=coverage.out
|
||||||
go tool cover -html=coverage.out
|
go tool cover -html=coverage.out
|
||||||
|
|
||||||
|
# The package builds only compile. The final line links an android binary so a linker-only failure
|
||||||
|
# cannot pass CI.
|
||||||
build-test-mobile:
|
build-test-mobile:
|
||||||
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=ios go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=amd64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
GOARCH=arm64 GOOS=android go build $(shell go list ./... | grep -v '/cmd/\|/examples/')
|
||||||
|
GOARCH=arm64 GOOS=android go build -o /dev/null ${NEBULA_CMD_PATH}
|
||||||
|
|
||||||
bench:
|
bench:
|
||||||
go test -bench=.
|
go test -bench=.
|
||||||
@@ -256,29 +279,75 @@ 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
|
||||||
cd .github/workflows/smoke/ && ./build.sh
|
# This is so we can limit `fips140` smoke test to just P256 curve.
|
||||||
cd .github/workflows/smoke/ && ./smoke.sh
|
if [ "$(CURVE)" != "P256" ]; then cd .github/workflows/smoke/ && $(GOENV) ./build.sh; fi
|
||||||
cd .github/workflows/smoke/ && NAME="smoke-p256" CURVE="P256" ./build.sh
|
if [ "$(CURVE)" != "P256" ]; then cd .github/workflows/smoke/ && $(GOENV) ./smoke.sh; fi
|
||||||
cd .github/workflows/smoke/ && NAME="smoke-p256" ./smoke.sh
|
cd .github/workflows/smoke/ && $(GOENV) NAME="smoke-p256" CURVE="P256" ./build.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/ && ./build-relay.sh
|
cd .github/workflows/smoke/ && $(GOENV) ./build-relay.sh
|
||||||
cd .github/workflows/smoke/ && ./smoke-relay.sh
|
cd .github/workflows/smoke/ && $(GOENV) ./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-docker-race: BUILD_ARGS = -race
|
smoke-self: bin
|
||||||
smoke-docker-race: CGO_ENABLED = 1
|
cd .github/workflows/smoke/ && ./smoke-self.sh
|
||||||
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 build-test-mobile e2e e2ev e2evv e2evvv e2evvvv proto release service smoke-docker smoke-docker-race test test-cov-html smoke-vagrant/%
|
.PHONY: all all-linux all-freebsd all-openbsd all-netbsd all-darwin all-windows all-cross-linux all-cross-linux-arm all-cross-linux-mips all-cross-linux-other all-cross-darwin all-cross-windows bench bench-cpu bench-cpu-long bin 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/%
|
||||||
.DEFAULT_GOAL := bin
|
.DEFAULT_GOAL := bin
|
||||||
@@ -145,17 +145,27 @@ 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 BoringCrypto
|
## Curve P256 and FIPS 140-3 mode
|
||||||
|
|
||||||
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.
|
||||||
|
|
||||||
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:
|
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).
|
||||||
|
|
||||||
|
```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,13 +79,7 @@ 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 := uint64(64) - bit
|
take := min(min(uint64(64)-bit, remaining), b.length-pos)
|
||||||
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
|
||||||
@@ -189,10 +183,7 @@ 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 := i
|
end := min(i, b.current+b.length)
|
||||||
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 := 0; i < 1000; i++ {
|
for i := range 1000 {
|
||||||
if i&1 == 1 {
|
if i&1 == 1 {
|
||||||
tbs.Version = Version1
|
tbs.Version = Version1
|
||||||
} else {
|
} else {
|
||||||
|
|||||||
+34
-7
@@ -3,11 +3,14 @@ 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"
|
||||||
"math"
|
"math"
|
||||||
|
"math/bits"
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"os"
|
"os"
|
||||||
"strings"
|
"strings"
|
||||||
@@ -43,7 +46,28 @@ 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
|
||||||
|
// RFC9106's recommendation for memory-constrained environments
|
||||||
|
var (
|
||||||
|
defaultArgonMemory uint
|
||||||
|
defaultArgonIterations uint
|
||||||
|
)
|
||||||
|
if bits.UintSize == 32 {
|
||||||
|
defaultArgonMemory = 64 * 1024
|
||||||
|
defaultArgonIterations = 3
|
||||||
|
} else {
|
||||||
|
defaultArgonMemory = 2 * 1024 * 1024
|
||||||
|
defaultArgonIterations = 1
|
||||||
|
}
|
||||||
|
|
||||||
cf := caFlags{set: flag.NewFlagSet("ca", flag.ContinueOnError)}
|
cf := caFlags{set: flag.NewFlagSet("ca", flag.ContinueOnError)}
|
||||||
cf.set.Usage = func() {}
|
cf.set.Usage = func() {}
|
||||||
cf.name = cf.set.String("name", "", "Required: name of the certificate authority")
|
cf.name = cf.set.String("name", "", "Required: name of the certificate authority")
|
||||||
@@ -55,11 +79,11 @@ func newCaFlags() *caFlags {
|
|||||||
cf.groups = cf.set.String("groups", "", "Optional: comma separated list of groups. This will limit which groups subordinate certs can use")
|
cf.groups = cf.set.String("groups", "", "Optional: comma separated list of groups. This will limit which groups subordinate certs can use")
|
||||||
cf.networks = cf.set.String("networks", "", "Optional: comma separated list of ip address and network in CIDR notation. This will limit which ip addresses and networks subordinate certs can use in networks")
|
cf.networks = cf.set.String("networks", "", "Optional: comma separated list of ip address and network in CIDR notation. This will limit which ip addresses and networks subordinate certs can use in networks")
|
||||||
cf.unsafeNetworks = cf.set.String("unsafe-networks", "", "Optional: comma separated list of ip address and network in CIDR notation. This will limit which ip addresses and networks subordinate certs can use in unsafe networks")
|
cf.unsafeNetworks = cf.set.String("unsafe-networks", "", "Optional: comma separated list of ip address and network in CIDR notation. This will limit which ip addresses and networks subordinate certs can use in unsafe networks")
|
||||||
cf.argonMemory = cf.set.Uint("argon-memory", 2*1024*1024, "Optional: Argon2 memory parameter (in KiB) used for encrypted private key passphrase")
|
cf.argonMemory = cf.set.Uint("argon-memory", defaultArgonMemory, "Optional: Argon2 memory parameter (in KiB) 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.argonParallelism = cf.set.Uint("argon-parallelism", 4, "Optional: Argon2 parallelism parameter used for encrypted private key passphrase")
|
||||||
cf.argonIterations = cf.set.Uint("argon-iterations", 1, "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", "25519", "EdDSA/ECDSA Curve (25519, P256)")
|
cf.curve = cf.set.String("curve", defaultCurve(), "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")
|
||||||
@@ -127,7 +151,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.Split(*cf.groups, ",") {
|
for rg := range strings.SplitSeq(*cf.groups, ",") {
|
||||||
g := strings.TrimSpace(rg)
|
g := strings.TrimSpace(rg)
|
||||||
if g != "" {
|
if g != "" {
|
||||||
groups = append(groups, g)
|
groups = append(groups, g)
|
||||||
@@ -147,7 +171,7 @@ func ca(args []string, out io.Writer, errOut io.Writer, pr PasswordReader) error
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *cf.networks != "" {
|
if *cf.networks != "" {
|
||||||
for _, rs := range strings.Split(*cf.networks, ",") {
|
for rs := range strings.SplitSeq(*cf.networks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -169,7 +193,7 @@ func ca(args []string, out io.Writer, errOut io.Writer, pr PasswordReader) error
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *cf.unsafeNetworks != "" {
|
if *cf.unsafeNetworks != "" {
|
||||||
for _, rs := range strings.Split(*cf.unsafeNetworks, ",") {
|
for rs := range strings.SplitSeq(*cf.unsafeNetworks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -197,7 +221,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 i := 0; i < 5; i++ {
|
for range 5 {
|
||||||
errOut.Write([]byte("Enter passphrase: "))
|
errOut.Write([]byte("Enter passphrase: "))
|
||||||
passphrase, err = pr.ReadPassword()
|
passphrase, err = pr.ReadPassword()
|
||||||
|
|
||||||
@@ -244,6 +268,9 @@ 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,5 +1,4 @@
|
|||||||
//go:build !windows
|
//go:build !windows
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
@@ -7,7 +6,9 @@ import (
|
|||||||
"bytes"
|
"bytes"
|
||||||
"encoding/pem"
|
"encoding/pem"
|
||||||
"errors"
|
"errors"
|
||||||
|
"math/bits"
|
||||||
"os"
|
"os"
|
||||||
|
"strconv"
|
||||||
"strings"
|
"strings"
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
@@ -22,6 +23,18 @@ func Test_caSummary(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func Test_caHelp(t *testing.T) {
|
func Test_caHelp(t *testing.T) {
|
||||||
|
var (
|
||||||
|
defaultArgonMemory string
|
||||||
|
defaultArgonIterations string
|
||||||
|
)
|
||||||
|
if bits.UintSize == 32 {
|
||||||
|
defaultArgonMemory = strconv.Itoa(64 * 1024)
|
||||||
|
defaultArgonIterations = strconv.Itoa(3)
|
||||||
|
} else {
|
||||||
|
defaultArgonMemory = strconv.Itoa(2 * 1024 * 1024)
|
||||||
|
defaultArgonIterations = strconv.Itoa(1)
|
||||||
|
}
|
||||||
|
|
||||||
ob := &bytes.Buffer{}
|
ob := &bytes.Buffer{}
|
||||||
caHelp(ob)
|
caHelp(ob)
|
||||||
assert.Equal(
|
assert.Equal(
|
||||||
@@ -29,9 +42,9 @@ func Test_caHelp(t *testing.T) {
|
|||||||
"Usage of "+os.Args[0]+" ca <flags>: create a self signed certificate authority\n"+
|
"Usage of "+os.Args[0]+" ca <flags>: create a self signed certificate authority\n"+
|
||||||
" Pass \"-\" to any path flag to read from stdin or write to stdout.\n"+
|
" Pass \"-\" to any path flag to read from stdin or write to stdout.\n"+
|
||||||
" -argon-iterations uint\n"+
|
" -argon-iterations uint\n"+
|
||||||
" \tOptional: Argon2 iterations parameter used for encrypted private key passphrase (default 1)\n"+
|
" \tOptional: Argon2 iterations parameter used for encrypted private key passphrase (default "+defaultArgonIterations+")\n"+
|
||||||
" -argon-memory uint\n"+
|
" -argon-memory uint\n"+
|
||||||
" \tOptional: Argon2 memory parameter (in KiB) used for encrypted private key passphrase (default 2097152)\n"+
|
" \tOptional: Argon2 memory parameter (in KiB) used for encrypted private key passphrase (default "+defaultArgonMemory+")\n"+
|
||||||
" -argon-parallelism uint\n"+
|
" -argon-parallelism uint\n"+
|
||||||
" \tOptional: Argon2 parallelism parameter used for encrypted private key passphrase (default 4)\n"+
|
" \tOptional: Argon2 parallelism parameter used for encrypted private key passphrase (default 4)\n"+
|
||||||
" -curve string\n"+
|
" -curve string\n"+
|
||||||
@@ -188,10 +201,16 @@ func Test_ca(t *testing.T) {
|
|||||||
k, _ := pem.Decode(rb)
|
k, _ := pem.Decode(rb)
|
||||||
ned, err := cert.UnmarshalNebulaEncryptedData(k.Bytes)
|
ned, err := cert.UnmarshalNebulaEncryptedData(k.Bytes)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
// we won't know salt in advance, so just check start of string
|
|
||||||
|
if bits.UintSize == 32 {
|
||||||
|
assert.Equal(t, uint32(64*1024), ned.EncryptionMetadata.Argon2Parameters.Memory)
|
||||||
|
assert.Equal(t, uint32(3), ned.EncryptionMetadata.Argon2Parameters.Iterations)
|
||||||
|
} else {
|
||||||
assert.Equal(t, uint32(2*1024*1024), ned.EncryptionMetadata.Argon2Parameters.Memory)
|
assert.Equal(t, uint32(2*1024*1024), ned.EncryptionMetadata.Argon2Parameters.Memory)
|
||||||
assert.Equal(t, uint8(4), ned.EncryptionMetadata.Argon2Parameters.Parallelism)
|
|
||||||
assert.Equal(t, uint32(1), ned.EncryptionMetadata.Argon2Parameters.Iterations)
|
assert.Equal(t, uint32(1), ned.EncryptionMetadata.Argon2Parameters.Iterations)
|
||||||
|
}
|
||||||
|
|
||||||
|
assert.Equal(t, uint8(4), ned.EncryptionMetadata.Argon2Parameters.Parallelism)
|
||||||
|
|
||||||
// verify the key is valid and decrypt-able
|
// verify the key is valid and decrypt-able
|
||||||
var curve cert.Curve
|
var curve cert.Curve
|
||||||
|
|||||||
@@ -0,0 +1,5 @@
|
|||||||
|
//go:build fips140enforce
|
||||||
|
|
||||||
|
//go:debug fips140=only
|
||||||
|
|
||||||
|
package main
|
||||||
@@ -1,6 +1,8 @@
|
|||||||
package main
|
package main
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"crypto/fips140"
|
||||||
|
"errors"
|
||||||
"flag"
|
"flag"
|
||||||
"fmt"
|
"fmt"
|
||||||
"io"
|
"io"
|
||||||
@@ -24,7 +26,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", "25519", "ECDH Curve (25519, P256)")
|
cf.curve = cf.set.String("curve", defaultCurve(), "ECDH Curve (25519, P256)")
|
||||||
cf.p11url = p11Flag(cf.set)
|
cf.p11url = p11Flag(cf.set)
|
||||||
return &cf
|
return &cf
|
||||||
}
|
}
|
||||||
@@ -61,6 +63,9 @@ 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,6 +2,7 @@ package main
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"crypto/ecdh"
|
"crypto/ecdh"
|
||||||
|
"crypto/fips140"
|
||||||
"crypto/rand"
|
"crypto/rand"
|
||||||
"errors"
|
"errors"
|
||||||
"flag"
|
"flag"
|
||||||
@@ -145,7 +146,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 i := 0; i < 5; i++ {
|
for range 5 {
|
||||||
errOut.Write([]byte("Enter passphrase: "))
|
errOut.Write([]byte("Enter passphrase: "))
|
||||||
passphrase, err = pr.ReadPassword()
|
passphrase, err = pr.ReadPassword()
|
||||||
|
|
||||||
@@ -202,7 +203,7 @@ func signCert(args []string, out io.Writer, errOut io.Writer, pr PasswordReader)
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *sf.networks != "" {
|
if *sf.networks != "" {
|
||||||
for _, rs := range strings.Split(*sf.networks, ",") {
|
for rs := range strings.SplitSeq(*sf.networks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -227,7 +228,7 @@ func signCert(args []string, out io.Writer, errOut io.Writer, pr PasswordReader)
|
|||||||
}
|
}
|
||||||
|
|
||||||
if *sf.unsafeNetworks != "" {
|
if *sf.unsafeNetworks != "" {
|
||||||
for _, rs := range strings.Split(*sf.unsafeNetworks, ",") {
|
for rs := range strings.SplitSeq(*sf.unsafeNetworks, ",") {
|
||||||
rs := strings.Trim(rs, " ")
|
rs := strings.Trim(rs, " ")
|
||||||
if rs != "" {
|
if rs != "" {
|
||||||
n, err := netip.ParsePrefix(rs)
|
n, err := netip.ParsePrefix(rs)
|
||||||
@@ -246,7 +247,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.Split(*sf.groups, ",") {
|
for rg := range strings.SplitSeq(*sf.groups, ",") {
|
||||||
g := strings.TrimSpace(rg)
|
g := strings.TrimSpace(rg)
|
||||||
if g != "" {
|
if g != "" {
|
||||||
groups = append(groups, g)
|
groups = append(groups, g)
|
||||||
@@ -268,6 +269,10 @@ 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,5 +1,4 @@
|
|||||||
//go:build !windows
|
//go:build !windows
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,5 @@
|
|||||||
|
//go:build fips140enforce
|
||||||
|
|
||||||
|
//go:debug fips140=only
|
||||||
|
|
||||||
|
package main
|
||||||
@@ -1,5 +1,4 @@
|
|||||||
//go:build !windows
|
//go:build !windows
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,5 @@
|
|||||||
|
//go:build fips140enforce
|
||||||
|
|
||||||
|
//go:debug fips140=only
|
||||||
|
|
||||||
|
package main
|
||||||
@@ -1,5 +1,4 @@
|
|||||||
//go:build !linux
|
//go:build !linux
|
||||||
// +build !linux
|
|
||||||
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
|
|||||||
+6
-9
@@ -5,6 +5,7 @@ import (
|
|||||||
"errors"
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
|
"maps"
|
||||||
"math"
|
"math"
|
||||||
"os"
|
"os"
|
||||||
"os/signal"
|
"os/signal"
|
||||||
@@ -154,9 +155,7 @@ func (c *C) ReloadConfig() {
|
|||||||
defer c.reloadLock.Unlock()
|
defer c.reloadLock.Unlock()
|
||||||
|
|
||||||
c.oldSettings = make(map[string]any)
|
c.oldSettings = make(map[string]any)
|
||||||
for k, v := range c.Settings {
|
maps.Copy(c.oldSettings, c.Settings)
|
||||||
c.oldSettings[k] = v
|
|
||||||
}
|
|
||||||
|
|
||||||
err := c.Load(c.path)
|
err := c.Load(c.path)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
@@ -177,9 +176,7 @@ 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)
|
||||||
for k, v := range c.Settings {
|
maps.Copy(c.oldSettings, c.Settings)
|
||||||
c.oldSettings[k] = v
|
|
||||||
}
|
|
||||||
|
|
||||||
err := c.LoadString(raw)
|
err := c.LoadString(raw)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
@@ -216,7 +213,7 @@ func (c *C) GetStringSlice(k string, d []string) []string {
|
|||||||
}
|
}
|
||||||
|
|
||||||
v := make([]string, len(rv))
|
v := make([]string, len(rv))
|
||||||
for i := 0; i < len(v); i++ {
|
for i := range v {
|
||||||
v[i] = fmt.Sprintf("%v", rv[i])
|
v[i] = fmt.Sprintf("%v", rv[i])
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -310,8 +307,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.Split(k, ".")
|
parts := strings.SplitSeq(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
|
||||||
|
|||||||
+36
-12
@@ -105,11 +105,18 @@ func (cm *connectionManager) getInactivityTimeout() time.Duration {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (cm *connectionManager) In(h *HostInfo) {
|
func (cm *connectionManager) In(h *HostInfo) {
|
||||||
h.in.Store(true)
|
h.markIn()
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cm *connectionManager) Out(h *HostInfo) {
|
// OutNoRebind records outbound traffic without consuming the rebind epoch, for relayed sends: the direct path
|
||||||
h.out.Store(true)
|
// to the relay consumes the edge, the via send must not.
|
||||||
|
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) {
|
||||||
@@ -128,8 +135,7 @@ 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 := h.in.Swap(false)
|
in, out := h.takeTraffic()
|
||||||
out := h.out.Swap(false)
|
|
||||||
if in || out {
|
if in || out {
|
||||||
h.lastUsed = now
|
h.lastUsed = now
|
||||||
}
|
}
|
||||||
@@ -168,10 +174,8 @@ func (cm *connectionManager) doTrafficCheck(localIndex uint32, p, nb, out []byte
|
|||||||
|
|
||||||
switch decision {
|
switch decision {
|
||||||
case deleteTunnel:
|
case deleteTunnel:
|
||||||
if cm.hostMap.DeleteHostInfo(hostinfo) {
|
// Local delete only, clearing the lighthouse cache if this was the last hostinfo for the vpn addr
|
||||||
// Only clearing the lighthouse cache if this is the last hostinfo for this vpn ip in the hostmap
|
cm.intf.closeTunnel(hostinfo)
|
||||||
cm.intf.lightHouse.DeleteVpnAddrs(hostinfo.vpnAddrs)
|
|
||||||
}
|
|
||||||
|
|
||||||
case closeTunnel:
|
case closeTunnel:
|
||||||
cm.intf.sendCloseTunnel(hostinfo)
|
cm.intf.sendCloseTunnel(hostinfo)
|
||||||
@@ -323,6 +327,12 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
|
|||||||
return closeTunnel, hostinfo, nil
|
return closeTunnel, hostinfo, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if hostinfo.ConnectionState != nil && hostinfo.ConnectionState.messageCounter.Load() >= RejectAfterMessages {
|
||||||
|
// Send path can't encrypt a CloseTunnel notify, so just delete locally; the peer recovers via recv_error.
|
||||||
|
hostinfo.logger(cm.l).Error("Dropping tunnel, message counter is exhausted")
|
||||||
|
return deleteTunnel, hostinfo, nil
|
||||||
|
}
|
||||||
|
|
||||||
primary := cm.hostMap.Hosts[hostinfo.vpnAddrs[0]]
|
primary := cm.hostMap.Hosts[hostinfo.vpnAddrs[0]]
|
||||||
mainHostInfo := true
|
mainHostInfo := true
|
||||||
if primary != nil && primary != hostinfo {
|
if primary != nil && primary != hostinfo {
|
||||||
@@ -340,7 +350,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
|
|||||||
"tunnelCheck", m{"state": "alive", "method": "passive"},
|
"tunnelCheck", m{"state": "alive", "method": "passive"},
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
hostinfo.pendingDeletion.Store(false)
|
hostinfo.setPendingDeletion(false)
|
||||||
|
|
||||||
if mainHostInfo {
|
if mainHostInfo {
|
||||||
decision = tryRehandshake
|
decision = tryRehandshake
|
||||||
@@ -363,7 +373,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
|
|||||||
return decision, hostinfo, primary
|
return decision, hostinfo, primary
|
||||||
}
|
}
|
||||||
|
|
||||||
if hostinfo.pendingDeletion.Load() {
|
if hostinfo.isPendingDeletion() {
|
||||||
// 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"},
|
||||||
@@ -414,7 +424,7 @@ func (cm *connectionManager) makeTrafficDecision(localIndex uint32, now time.Tim
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
hostinfo.pendingDeletion.Store(true)
|
hostinfo.setPendingDeletion(true)
|
||||||
cm.trafficTimer.Add(hostinfo.localIndexId, cm.pendingDeletionInterval)
|
cm.trafficTimer.Add(hostinfo.localIndexId, cm.pendingDeletionInterval)
|
||||||
return decision, hostinfo, nil
|
return decision, hostinfo, nil
|
||||||
}
|
}
|
||||||
@@ -448,6 +458,11 @@ func (cm *connectionManager) shouldSwapPrimary(current *HostInfo) bool {
|
|||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if current.ConnectionState.messageCounter.Load() >= RehandshakeAfterMessages {
|
||||||
|
// This tunnel is being rolled for counter exhaustion, never swap back onto its spent key.
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
crt := cm.intf.pki.getCertState().getCertificate(current.ConnectionState.myCert.Version())
|
crt := cm.intf.pki.getCertState().getCertificate(current.ConnectionState.myCert.Version())
|
||||||
if crt == nil {
|
if crt == nil {
|
||||||
//my cert was reloaded away. We should definitely swap from this tunnel
|
//my cert was reloaded away. We should definitely swap from this tunnel
|
||||||
@@ -544,6 +559,15 @@ func (cm *connectionManager) tryRehandshake(hostinfo *HostInfo) {
|
|||||||
"reason", "current cert version < pki.initiatingVersion",
|
"reason", "current cert version < pki.initiatingVersion",
|
||||||
)
|
)
|
||||||
|
|
||||||
|
cm.intf.handshakeManager.StartHandshake(hostinfo.vpnAddrs[0], nil)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if hostinfo.ConnectionState.messageCounter.Load() >= RehandshakeAfterMessages {
|
||||||
|
cm.l.Info("Re-handshaking with remote",
|
||||||
|
"vpnAddrs", hostinfo.vpnAddrs,
|
||||||
|
"reason", "message counter rehandshake threshold reached",
|
||||||
|
)
|
||||||
|
|
||||||
cm.intf.handshakeManager.StartHandshake(hostinfo.vpnAddrs[0], nil)
|
cm.intf.handshakeManager.StartHandshake(hostinfo.vpnAddrs[0], nil)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|||||||
+112
-36
@@ -7,6 +7,7 @@ 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"
|
||||||
@@ -21,6 +22,8 @@ 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{}{}
|
||||||
@@ -86,25 +89,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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
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.out.Load())
|
assert.True(t, hostinfo.sentSinceCheck())
|
||||||
assert.True(t, hostinfo.in.Load())
|
assert.True(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
|
|
||||||
// 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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
|
|
||||||
// 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.out.Load())
|
assert.True(t, hostinfo.sentSinceCheck())
|
||||||
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
nc.doTrafficCheck(hostinfo.localIndexId, p, nb, out, time.Now())
|
||||||
assert.True(t, hostinfo.pendingDeletion.Load())
|
assert.True(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
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])
|
||||||
|
|
||||||
@@ -168,37 +171,110 @@ 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.in.Load())
|
assert.True(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
assert.True(t, hostinfo.out.Load())
|
assert.True(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
|
|
||||||
// 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.pendingDeletion.Load())
|
assert.True(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
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])
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func Test_NewConnectionManager_CounterLimits(t *testing.T) {
|
||||||
|
l := test.NewLogger()
|
||||||
|
localrange := netip.MustParsePrefix("10.1.1.1/24")
|
||||||
|
vpnIp := netip.MustParseAddr("172.1.1.2")
|
||||||
|
preferredRanges := []netip.Prefix{localrange}
|
||||||
|
|
||||||
|
// Very incomplete mock objects
|
||||||
|
hostMap := newHostMap(l)
|
||||||
|
hostMap.preferredRanges.Store(&preferredRanges)
|
||||||
|
|
||||||
|
cs := &CertState{
|
||||||
|
initiatingVersion: cert.Version1,
|
||||||
|
privateKey: []byte{},
|
||||||
|
v1Cert: &dummyCert{version: cert.Version1},
|
||||||
|
v1Credential: nil,
|
||||||
|
}
|
||||||
|
|
||||||
|
lh := newTestLighthouse()
|
||||||
|
ifce := &Interface{
|
||||||
|
hostMap: hostMap,
|
||||||
|
inside: &overlaytest.NoopTun{},
|
||||||
|
outside: &udp.NoopConn{},
|
||||||
|
firewall: &Firewall{},
|
||||||
|
lightHouse: lh,
|
||||||
|
pki: &PKI{},
|
||||||
|
myVpnAddrs: []netip.Addr{netip.MustParseAddr("172.1.1.1")}, // sorts below vpnIp so shouldSwapPrimary can proceed
|
||||||
|
handshakeManager: NewHandshakeManager(l, hostMap, lh, &udp.NoopConn{}, defaultHandshakeConfig),
|
||||||
|
l: l,
|
||||||
|
}
|
||||||
|
ifce.pki.cs.Store(cs)
|
||||||
|
|
||||||
|
conf := config.NewC(test.NewLogger())
|
||||||
|
punchy := NewPunchyFromConfig(test.NewLogger(), conf, nil)
|
||||||
|
nc := newConnectionManagerFromConfig(test.NewLogger(), conf, hostMap, punchy)
|
||||||
|
nc.intf = ifce
|
||||||
|
|
||||||
|
hostinfo := &HostInfo{
|
||||||
|
vpnAddrs: []netip.Addr{vpnIp},
|
||||||
|
localIndexId: 1099,
|
||||||
|
remoteIndexId: 9901,
|
||||||
|
}
|
||||||
|
hostinfo.ConnectionState = &ConnectionState{
|
||||||
|
myCert: &dummyCert{version: cert.Version1},
|
||||||
|
}
|
||||||
|
nc.hostMap.unlockedAddHostInfo(hostinfo, ifce)
|
||||||
|
|
||||||
|
// Below the rehandshake threshold, no handshake is started
|
||||||
|
hostinfo.ConnectionState.messageCounter.Store(RehandshakeAfterMessages - 1)
|
||||||
|
nc.tryRehandshake(hostinfo)
|
||||||
|
assert.Nil(t, ifce.handshakeManager.QueryVpnAddr(vpnIp))
|
||||||
|
|
||||||
|
// A tunnel on its current cert would normally swap to primary
|
||||||
|
assert.True(t, nc.shouldSwapPrimary(hostinfo))
|
||||||
|
|
||||||
|
// At the rehandshake threshold, a new handshake is started
|
||||||
|
hostinfo.ConnectionState.messageCounter.Store(RehandshakeAfterMessages)
|
||||||
|
nc.tryRehandshake(hostinfo)
|
||||||
|
assert.NotNil(t, ifce.handshakeManager.QueryVpnAddr(vpnIp))
|
||||||
|
|
||||||
|
// An exhausted tunnel being rolled must never swap back to primary onto its spent key
|
||||||
|
assert.False(t, nc.shouldSwapPrimary(hostinfo))
|
||||||
|
|
||||||
|
// Still below the reject limit, the tunnel stays up
|
||||||
|
nc.In(hostinfo)
|
||||||
|
decision, _, _ := nc.makeTrafficDecision(hostinfo.localIndexId, time.Now())
|
||||||
|
assert.Equal(t, tryRehandshake, decision)
|
||||||
|
|
||||||
|
// At the reject limit, the tunnel is deleted locally without a doomed CloseTunnel notify
|
||||||
|
hostinfo.ConnectionState.messageCounter.Store(RejectAfterMessages)
|
||||||
|
decision, _, _ = nc.makeTrafficDecision(hostinfo.localIndexId, time.Now())
|
||||||
|
assert.Equal(t, deleteTunnel, decision)
|
||||||
|
}
|
||||||
|
|
||||||
func Test_NewConnectionManager_DisconnectInactive(t *testing.T) {
|
func Test_NewConnectionManager_DisconnectInactive(t *testing.T) {
|
||||||
l := test.NewLogger()
|
l := test.NewLogger()
|
||||||
localrange := netip.MustParsePrefix("10.1.1.1/24")
|
localrange := netip.MustParsePrefix("10.1.1.1/24")
|
||||||
@@ -253,31 +329,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.out.Load())
|
assert.True(t, hostinfo.sentSinceCheck())
|
||||||
assert.True(t, hostinfo.in.Load())
|
assert.True(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
|
|
||||||
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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
|
|
||||||
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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
|
|
||||||
// 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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
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])
|
||||||
|
|
||||||
@@ -285,9 +361,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.pendingDeletion.Load())
|
assert.False(t, hostinfo.isPendingDeletion())
|
||||||
assert.False(t, hostinfo.out.Load())
|
assert.False(t, hostinfo.sentSinceCheck())
|
||||||
assert.False(t, hostinfo.in.Load())
|
assert.False(t, (hostinfo.state.Load()&stateIn != 0))
|
||||||
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])
|
||||||
}
|
}
|
||||||
|
|||||||
+48
-8
@@ -2,6 +2,7 @@ package nebula
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"encoding/json"
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
"sync"
|
"sync"
|
||||||
"sync/atomic"
|
"sync/atomic"
|
||||||
@@ -12,7 +13,26 @@ import (
|
|||||||
"github.com/slackhq/nebula/noiseutil"
|
"github.com/slackhq/nebula/noiseutil"
|
||||||
)
|
)
|
||||||
|
|
||||||
const ReplayWindow = 1024
|
const (
|
||||||
|
ReplayWindow = 8192
|
||||||
|
|
||||||
|
// RehandshakeAfterMessages rolls keys inside the AES-GCM data-volume margin (~2^-36 advantage at 64KB frames).
|
||||||
|
RehandshakeAfterMessages = uint64(1) << 34
|
||||||
|
|
||||||
|
// RejectAfterMessages is the nonce ceiling enforced by noiseutil; a tunnel here is deleted locally, not notified.
|
||||||
|
RejectAfterMessages = noiseutil.RejectAfterMessages
|
||||||
|
)
|
||||||
|
|
||||||
|
// RehandshakeAfterMessages must stay below RejectAfterMessages so tunnels roll before the hard send stop.
|
||||||
|
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
|
||||||
@@ -24,13 +44,20 @@ 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
|
||||||
// completed handshake.Result. It seeds messageCounter and the replay window so
|
// completed handshake.Result. It seeds messageCounter and the replay window so
|
||||||
// that the post-handshake message indices already used on the wire don't count
|
// that the post-handshake message indices already used on the wire don't count
|
||||||
// as missed traffic in the data plane.
|
// as missed traffic in the data plane.
|
||||||
func newConnectionStateFromResult(r *handshake.Result) *ConnectionState {
|
func newConnectionStateFromResult(r *handshake.Result) (*ConnectionState, error) {
|
||||||
|
// Refuse a MessageIndex too big for the replay window: it can only be a bug, and would spin the seed loop below.
|
||||||
|
if r.MessageIndex >= ReplayWindow {
|
||||||
|
return nil, fmt.Errorf("handshake message index %d exceeds replay window", r.MessageIndex)
|
||||||
|
}
|
||||||
|
|
||||||
ci := &ConnectionState{
|
ci := &ConnectionState{
|
||||||
myCert: r.MyCert,
|
myCert: r.MyCert,
|
||||||
initiator: r.Initiator,
|
initiator: r.Initiator,
|
||||||
@@ -38,12 +65,13 @@ func newConnectionStateFromResult(r *handshake.Result) *ConnectionState {
|
|||||||
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++ {
|
||||||
ci.window.Update(nil, i)
|
ci.window.Update(nil, i)
|
||||||
}
|
}
|
||||||
return ci
|
return ci, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cs *ConnectionState) MarshalJSON() ([]byte, error) {
|
func (cs *ConnectionState) MarshalJSON() ([]byte, error) {
|
||||||
@@ -54,12 +82,21 @@ func (cs *ConnectionState) MarshalJSON() ([]byte, error) {
|
|||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// NextMessageCounter reserves the next 1-based counter; RejectAfterMessages is the first we refuse, pinned to not wrap.
|
||||||
|
func (cs *ConnectionState) NextMessageCounter() (uint64, bool) {
|
||||||
|
c := cs.messageCounter.Add(1)
|
||||||
|
if c >= RejectAfterMessages {
|
||||||
|
cs.messageCounter.Store(RejectAfterMessages)
|
||||||
|
return c, false
|
||||||
|
}
|
||||||
|
return c, true
|
||||||
|
}
|
||||||
|
|
||||||
func (cs *ConnectionState) Curve() cert.Curve {
|
func (cs *ConnectionState) Curve() cert.Curve {
|
||||||
return cs.myCert.Curve()
|
return cs.myCert.Curve()
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, out []byte, packet []byte, nb []byte) ([]byte, error) {
|
func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, 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()
|
||||||
@@ -67,7 +104,7 @@ func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, out []
|
|||||||
return nil, ErrAlreadySeen
|
return nil, ErrAlreadySeen
|
||||||
}
|
}
|
||||||
|
|
||||||
out, err = cs.dKey.DecryptDanger(out, packet[:header.Len], packet[header.Len:], messageCounter, nb)
|
out, err := cs.dKey.DecryptDanger(packet[header.Len:header.Len], packet[:header.Len], packet[header.Len:], messageCounter, nb)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
@@ -81,7 +118,6 @@ func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, out []
|
|||||||
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)
|
||||||
@@ -90,6 +126,11 @@ 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)
|
||||||
@@ -103,6 +144,5 @@ func (cs *ConnectionState) VerifyRelay(l *slog.Logger, messageCounter uint64, pa
|
|||||||
if !result {
|
if !result {
|
||||||
return ErrAlreadySeen
|
return ErrAlreadySeen
|
||||||
}
|
}
|
||||||
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
+199
-2
@@ -2,14 +2,20 @@ package nebula
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"net/netip"
|
"net/netip"
|
||||||
|
"strconv"
|
||||||
|
"sync"
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/flynn/noise"
|
"github.com/flynn/noise"
|
||||||
|
"github.com/rcrowley/go-metrics"
|
||||||
"github.com/slackhq/nebula/cert"
|
"github.com/slackhq/nebula/cert"
|
||||||
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/udp"
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
)
|
)
|
||||||
@@ -79,11 +85,193 @@ func runTestHandshake(t *testing.T) (initR, respR *handshake.Result) {
|
|||||||
return initR, respR
|
return initR, respR
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func TestConnectionState_NextMessageCounter(t *testing.T) {
|
||||||
|
cs := &ConnectionState{}
|
||||||
|
cs.messageCounter.Store(RejectAfterMessages - 2)
|
||||||
|
|
||||||
|
c, ok := cs.NextMessageCounter()
|
||||||
|
assert.True(t, ok)
|
||||||
|
assert.Equal(t, RejectAfterMessages-1, c)
|
||||||
|
|
||||||
|
// Hitting the limit refuses and pins the counter there
|
||||||
|
c, ok = cs.NextMessageCounter()
|
||||||
|
assert.False(t, ok)
|
||||||
|
assert.Equal(t, RejectAfterMessages, c)
|
||||||
|
assert.Equal(t, RejectAfterMessages, cs.messageCounter.Load())
|
||||||
|
|
||||||
|
// Continued send attempts stay refused and the counter never wraps
|
||||||
|
for range 10 {
|
||||||
|
_, ok = cs.NextMessageCounter()
|
||||||
|
assert.False(t, ok)
|
||||||
|
}
|
||||||
|
assert.Equal(t, RejectAfterMessages, cs.messageCounter.Load())
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestSendNoMetricsDropsExhausted drives the send path to the exhausted drop; metric and out flag prove it.
|
||||||
|
func TestSendNoMetricsDropsExhausted(t *testing.T) {
|
||||||
|
initR, _ := runTestHandshake(t)
|
||||||
|
ci, err := newConnectionStateFromResult(initR)
|
||||||
|
require.NoError(t, err)
|
||||||
|
ci.messageCounter.Store(RejectAfterMessages - 1)
|
||||||
|
|
||||||
|
f := &Interface{l: test.NewLogger(), messageMetrics: &MessageMetrics{txExhausted: metrics.NewCounter()}}
|
||||||
|
hostinfo := &HostInfo{vpnAddrs: []netip.Addr{netip.MustParseAddr("10.0.0.1")}, ConnectionState: ci}
|
||||||
|
|
||||||
|
f.sendNoMetrics(header.Message, 0, ci, hostinfo, netip.AddrPort{}, []byte{}, make([]byte, 12), make([]byte, mtu), 0)
|
||||||
|
|
||||||
|
// 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.False(t, hostinfo.sentSinceCheck())
|
||||||
|
}
|
||||||
|
|
||||||
|
// 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) {
|
||||||
initR, respR := runTestHandshake(t)
|
initR, respR := runTestHandshake(t)
|
||||||
|
|
||||||
t.Run("initiator", func(t *testing.T) {
|
t.Run("initiator", func(t *testing.T) {
|
||||||
ci := newConnectionStateFromResult(initR)
|
ci, err := newConnectionStateFromResult(initR)
|
||||||
|
require.NoError(t, err)
|
||||||
assert.True(t, ci.initiator)
|
assert.True(t, ci.initiator)
|
||||||
assert.Equal(t, initR.MyCert, ci.myCert)
|
assert.Equal(t, initR.MyCert, ci.myCert)
|
||||||
assert.Equal(t, initR.RemoteCert, ci.peerCert)
|
assert.Equal(t, initR.RemoteCert, ci.peerCert)
|
||||||
@@ -102,8 +290,17 @@ func TestNewConnectionStateFromResult(t *testing.T) {
|
|||||||
assert.True(t, ci.window.Check(nil, 3), "counter 3 must not be pre-seeded")
|
assert.True(t, ci.window.Check(nil, 3), "counter 3 must not be pre-seeded")
|
||||||
})
|
})
|
||||||
|
|
||||||
|
t.Run("message index too large is refused", func(t *testing.T) {
|
||||||
|
bad := *initR
|
||||||
|
bad.MessageIndex = ReplayWindow
|
||||||
|
ci, err := newConnectionStateFromResult(&bad)
|
||||||
|
require.Error(t, err)
|
||||||
|
assert.Nil(t, ci)
|
||||||
|
})
|
||||||
|
|
||||||
t.Run("responder", func(t *testing.T) {
|
t.Run("responder", func(t *testing.T) {
|
||||||
ci := newConnectionStateFromResult(respR)
|
ci, err := newConnectionStateFromResult(respR)
|
||||||
|
require.NoError(t, err)
|
||||||
assert.False(t, ci.initiator)
|
assert.False(t, ci.initiator)
|
||||||
assert.Equal(t, respR.MyCert, ci.myCert)
|
assert.Equal(t, respR.MyCert, ci.myCert)
|
||||||
assert.Equal(t, respR.RemoteCert, ci.peerCert)
|
assert.Equal(t, respR.RemoteCert, ci.peerCert)
|
||||||
|
|||||||
+2
-2
@@ -115,7 +115,7 @@ func (c *Control) Start() error {
|
|||||||
c.lighthouseStart()
|
c.lighthouseStart()
|
||||||
}
|
}
|
||||||
|
|
||||||
c.f.triggerShutdown = c.Stop
|
c.f.triggerShutdown = func() { go 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.rebindCount++
|
c.f.rebindEpoch.Add(1)
|
||||||
}
|
}
|
||||||
|
|
||||||
// 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
|
||||||
|
|||||||
+35
-18
@@ -11,6 +11,8 @@ 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"
|
||||||
@@ -30,9 +32,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(p []byte) (int, error) {
|
func (d *fakeDevice) Read() ([]tio.Packet, error) {
|
||||||
<-d.closedCh
|
<-d.closedCh
|
||||||
return 0, io.EOF
|
return nil, 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 }
|
||||||
@@ -49,10 +51,8 @@ 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) NewMultiQueueReader() (io.ReadWriteCloser, error) {
|
func (d *fakeDevice) Queues(int) ([]tio.Queue, error) { return []tio.Queue{d}, nil }
|
||||||
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},
|
||||||
readers: make([]io.ReadWriteCloser, 1),
|
batchers: make([]*batch.MultiCoalescer, 1),
|
||||||
routines: 1,
|
routines: 1,
|
||||||
hostMap: newHostMap(l),
|
hostMap: newHostMap(l),
|
||||||
lightHouse: lh,
|
lightHouse: lh,
|
||||||
@@ -109,7 +109,8 @@ 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
|
||||||
require.ErrorIs(t, c.Start(), ErrAlreadyStopped)
|
err := c.Start()
|
||||||
|
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()
|
||||||
@@ -145,8 +146,11 @@ 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) error { return nil }
|
func (c *fakeConn) ListenOut(_ udp.EncReader, _ func()) 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 }
|
||||||
@@ -155,7 +159,14 @@ type multiqueueDevice struct {
|
|||||||
*fakeDevice
|
*fakeDevice
|
||||||
}
|
}
|
||||||
|
|
||||||
func (d *multiqueueDevice) SupportsMultiqueue() bool { return true }
|
// Queues claims multiqueue support but fails to open the second queue,
|
||||||
|
// 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()}
|
||||||
@@ -166,7 +177,7 @@ func TestControl_StartMultiqueueFailureReleases(t *testing.T) {
|
|||||||
inside: dev,
|
inside: dev,
|
||||||
outside: conn,
|
outside: conn,
|
||||||
writers: []udp.Conn{conn},
|
writers: []udp.Conn{conn},
|
||||||
readers: make([]io.ReadWriteCloser, 2),
|
batchers: make([]*batch.MultiCoalescer, 2),
|
||||||
routines: 2,
|
routines: 2,
|
||||||
l: test.NewLogger(),
|
l: test.NewLogger(),
|
||||||
}
|
}
|
||||||
@@ -181,7 +192,8 @@ 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
|
||||||
require.Error(t, c.Start())
|
err := 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")
|
||||||
@@ -235,7 +247,7 @@ func TestControl_ConcurrentStopAndStart(t *testing.T) {
|
|||||||
c, _, _ := newReadyControl(t)
|
c, _, _ := newReadyControl(t)
|
||||||
|
|
||||||
var wg sync.WaitGroup
|
var wg sync.WaitGroup
|
||||||
for i := 0; i < 2; i++ {
|
for range 2 {
|
||||||
wg.Go(func() { c.Stop() })
|
wg.Go(func() { c.Stop() })
|
||||||
}
|
}
|
||||||
wg.Go(func() { _ = c.Start() })
|
wg.Go(func() { _ = c.Start() })
|
||||||
@@ -251,15 +263,18 @@ 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())
|
||||||
require.ErrorIs(t, c.Start(), ErrAlreadyStopped)
|
err := c.Start()
|
||||||
|
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)
|
||||||
|
|
||||||
require.NoError(t, c.Start())
|
err := c.Start()
|
||||||
|
require.NoError(t, err)
|
||||||
assert.Equal(t, StateStarted, c.State())
|
assert.Equal(t, StateStarted, c.State())
|
||||||
require.ErrorIs(t, c.Start(), ErrAlreadyStarted)
|
err = c.Start()
|
||||||
|
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()
|
||||||
@@ -270,7 +285,8 @@ 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())
|
||||||
require.ErrorIs(t, c.Start(), ErrAlreadyStopped)
|
err = c.Start()
|
||||||
|
require.ErrorIs(t, err, ErrAlreadyStopped)
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestControl_RebindIsGatedByState(t *testing.T) {
|
func TestControl_RebindIsGatedByState(t *testing.T) {
|
||||||
@@ -280,7 +296,8 @@ 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")
|
||||||
|
|
||||||
require.NoError(t, c.Start())
|
err := 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,6 +123,16 @@ 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 {
|
||||||
|
|||||||
@@ -0,0 +1,187 @@
|
|||||||
|
// 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.
|
||||||
|
package cpupick
|
||||||
|
|
||||||
|
import (
|
||||||
|
"log/slog"
|
||||||
|
|
||||||
|
"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. Returns nil when there is nothing useful to say (no affinity
|
||||||
|
// support on this platform, lookup failure); callers keep their existing
|
||||||
|
// fallback spread.
|
||||||
|
func Default(routines int, key uint64, l *slog.Logger) []int {
|
||||||
|
allowed, err := util.AllowedCPUs()
|
||||||
|
if err != nil || 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)
|
||||||
|
}
|
||||||
|
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)
|
||||||
|
}
|
||||||
@@ -0,0 +1,171 @@
|
|||||||
|
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)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,154 @@
|
|||||||
|
//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)))
|
||||||
|
}
|
||||||
@@ -0,0 +1,163 @@
|
|||||||
|
//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)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,10 @@
|
|||||||
|
//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, ""
|
||||||
|
}
|
||||||
@@ -0,0 +1,118 @@
|
|||||||
|
//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
|
||||||
|
}
|
||||||
@@ -0,0 +1,111 @@
|
|||||||
|
//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)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,10 @@
|
|||||||
|
//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)
|
||||||
|
}
|
||||||
@@ -0,0 +1,131 @@
|
|||||||
|
# Post-quantum handshake transport compared with QUIC
|
||||||
|
|
||||||
|
Status: analysis, 2026-10-14. Compares the fragment transport in
|
||||||
|
[pq-handshake.md](pq-handshake.md) with how QUIC makes its handshake reliable. TLS is out of
|
||||||
|
scope; only the transport mechanics are compared.
|
||||||
|
|
||||||
|
## Summary
|
||||||
|
|
||||||
|
QUIC's handshake reliability is closed-loop: the receiver acknowledges, and the sender
|
||||||
|
repairs exactly what is missing. Ours is open-loop: repair symbols are sent up front, and a
|
||||||
|
timer sends fresh symbols. At handshake sizes (K <= 15) a QUIC-style acknowledgement
|
||||||
|
shrinks to a 16-bit bitmap, and with an MDS code to a single count. So the real comparison
|
||||||
|
is forward error correction versus acknowledgements, not QUIC versus us.
|
||||||
|
|
||||||
|
FEC is the right core. One piece of feedback is worth adding, initiator to responder and for
|
||||||
|
msg2 only (see [Worth taking from QUIC](#worth-taking-from-quic)).
|
||||||
|
|
||||||
|
## What QUIC does
|
||||||
|
|
||||||
|
- **Messages as a stream.** Handshake bytes travel as `CRYPTO` frames (offset and length)
|
||||||
|
and are reassembled in order. Initial and Handshake packets each have their own packet
|
||||||
|
number space.
|
||||||
|
- **Immediate acknowledgements.** Receivers must acknowledge Initial and Handshake packets
|
||||||
|
without delay. ACK frames list ranges of received packet numbers.
|
||||||
|
- **Loss detection** (RFC 9002). A packet is lost once 3 later packets are acknowledged, or
|
||||||
|
after 9/8 of the round-trip time. Lost bytes are resent in new packets.
|
||||||
|
- **Probe timeout (PTO).** If a whole flight vanishes, a probe timer fires. Before any RTT
|
||||||
|
sample it starts at about 1 s (333 ms initial RTT plus 4x its variance) and doubles each
|
||||||
|
time. Both endpoints run it.
|
||||||
|
- **Amplification limit and anti-deadlock.** The server may send at most 3x what it
|
||||||
|
received until the client's address is validated. The client must keep probing so a
|
||||||
|
server stuck at that limit cannot deadlock.
|
||||||
|
- **Retry.** A stateless round trip to validate the address. `NEW_TOKEN` lets later
|
||||||
|
connections skip it.
|
||||||
|
- **Congestion control from the first packet.** The initial window is 10 packets of 1200
|
||||||
|
bytes.
|
||||||
|
|
||||||
|
## Side by side
|
||||||
|
|
||||||
|
| | QUIC | pq-handshake |
|
||||||
|
|---|---|---|
|
||||||
|
| Receiver feedback | ACK ranges, sent immediately | None; the next handshake message is the only acknowledgement |
|
||||||
|
| Partial loss | +1 to 2 RTT (ACK, detect, resend) | 0 RTT while at most m symbols are lost |
|
||||||
|
| Total loss | PTO: about 1 s, then doubling | Next PQ tick: 300 ms, then 1 s (alternating), or 100/300/600 ms (sticky) |
|
||||||
|
| Spurious retransmit | Wasted bytes | Still useful: fresh repair indexes add to what the receiver holds |
|
||||||
|
| Reassembly | Every byte offset, in order | Any K of up to 256 symbols |
|
||||||
|
| Who retransmits | Both sides on their own timers | Initiator on a timer; the responder resends msg2 only when a repeat msg1 arrives (rate limited) |
|
||||||
|
| State from the first packet | Server buffers and acknowledges partial flights | Capped pre-authentication table that never acknowledges |
|
||||||
|
| Address validation | Retry, 1 RTT | Cookie under load, 1 RTT |
|
||||||
|
|
||||||
|
From the [simulation results](pq-handshake.md#simulation-results): phase 2 at 5% random
|
||||||
|
loss with no FEC completes on the first attempt 39.8% of the time. Under
|
||||||
|
acknowledgement-based recovery roughly 60% of handshakes would pay at least one extra round
|
||||||
|
trip. With FEC, 0.4% wait for a retry. Spending bandwidth to save round trips is the stated
|
||||||
|
design preference, and open-loop recovery delivers it.
|
||||||
|
|
||||||
|
## Where the designs already agree
|
||||||
|
|
||||||
|
- **1200-byte floor and the 3x amplification budget**, both taken directly from QUIC.
|
||||||
|
- **Cookie and Retry.** Both cost one round trip and both can be forged by an on-path
|
||||||
|
attacker. QUIC's Retry integrity tag uses a fixed, published key.
|
||||||
|
- **On-path injection.** QUIC's Initial keys are derived from the client's connection ID,
|
||||||
|
which an observer can read, so QUIC accepts the same handshake-blocking injection
|
||||||
|
weakness documented for our symbols in
|
||||||
|
[Injected symbols](pq-handshake.md#injected-symbols).
|
||||||
|
- **Phase 2 msg3 confirmation.** Resending msg3 until any authenticated packet arrives,
|
||||||
|
with a `Test` from the responder on completion, is QUIC's handshake confirmation and
|
||||||
|
`HANDSHAKE_DONE`.
|
||||||
|
|
||||||
|
## Worth taking from QUIC
|
||||||
|
|
||||||
|
### 1. A msg2 progress probe from the initiator
|
||||||
|
|
||||||
|
This is the main gap. Today, recovering a partially lost msg2 means the initiator resends a
|
||||||
|
full msg1 attempt; the responder decodes it, matches it in the answered-msg1 cache, and
|
||||||
|
resends msg2. In phase 2 that is about 12 fragments (~13 KB) uploaded just to act as an
|
||||||
|
acknowledgement, and recovery waits for the 300 ms or 1 s tick.
|
||||||
|
|
||||||
|
- The initiator already knows the responder's index: msg2 fragments carry it as `FragID`
|
||||||
|
(`sendFragmentedResponse` passes `hostinfo.localIndexId`).
|
||||||
|
- A one-packet probe, "msg2: have n of K", sent to that index would recover in about one
|
||||||
|
round trip. The responder finds it the way phase 2 plans to find msg3.
|
||||||
|
- Timing comes for free: msg1 send to first msg2 fragment is an RTT sample. Probe at
|
||||||
|
roughly RTT/8 plus the repair delay after the first msg2 fragment if decoding has not
|
||||||
|
completed.
|
||||||
|
- Forging a probe needs the 32-bit responder index, so only an on-path attacker can, and
|
||||||
|
the existing 3x budget bounds the reply.
|
||||||
|
- If no msg2 fragment arrived at all, the initiator keeps today's msg1 resend. That is the
|
||||||
|
same tail-loss case QUIC's PTO covers.
|
||||||
|
|
||||||
|
The reverse direction, the responder reporting progress on msg1, should not be added. It
|
||||||
|
needs per-entry timers on the pre-authentication path, which is exactly the state QUIC
|
||||||
|
servers carry and the reason QUIC needs Retry.
|
||||||
|
|
||||||
|
### 2. Buffer early data in phase 2
|
||||||
|
|
||||||
|
QUIC stacks hold a few packets they cannot decrypt yet. The phase 2 plan drops data that
|
||||||
|
reaches the responder before msg3 decodes. Because repair fragments trail by
|
||||||
|
`handshakes.pq.repair_delay` (10 ms), losing one msg3 data fragment drops about 10 ms of
|
||||||
|
the initiator's first data while the repair is in flight. A small queue on the pending
|
||||||
|
responder entry, replayed once msg3 verifies, avoids this.
|
||||||
|
|
||||||
|
### 3. Burst size across remotes
|
||||||
|
|
||||||
|
QUIC handshakes on a single path. `handleOutbound` sends the same `now` and `later` sets to
|
||||||
|
every known remote and to relays (`StartRelays`).
|
||||||
|
|
||||||
|
- Phase 1 is fine.
|
||||||
|
- In phase 2, four remotes means about 48 packets (~54 KB) leaving one uplink at once,
|
||||||
|
every PQ tick, about 4x QUIC's initial window.
|
||||||
|
- The Gilbert-Elliott simulation treats each path independently, so it does not capture
|
||||||
|
this self-inflicted burst on a constrained uplink such as cellular.
|
||||||
|
- Options: send the full FEC set only to the most likely remote and a reduced set to the
|
||||||
|
others, or interleave packets across remotes.
|
||||||
|
|
||||||
|
## Not worth taking
|
||||||
|
|
||||||
|
- **Packet numbers, ACK ranges, an RTT estimator, loss thresholds, congestion control.**
|
||||||
|
QUIC pays for this machinery because it also serves a data transport. Nebula carries
|
||||||
|
packets and leaves reliability to the overlay's own transports. Building it only for
|
||||||
|
handshakes of at most 15 fragments buys nothing a symbol count cannot.
|
||||||
|
- **Offset-based reassembly.** It gives up the any-K-of-256 property and makes spurious
|
||||||
|
retransmits wasteful again.
|
||||||
|
- **An RTT-adaptive retry timer.** Low value. The fixed 100 ms linear schedule already fires
|
||||||
|
sooner than QUIC's 1 s first PTO, and a spurious resend costs bandwidth, not correctness.
|
||||||
|
|
||||||
|
## Conclusion
|
||||||
|
|
||||||
|
Keep FEC as the core and add the msg2 progress probe. That gets QUIC's roughly one round
|
||||||
|
trip tail recovery without pre-authentication state, and cuts phase 2's retry cost on the
|
||||||
|
uplink by about 10x. Items 2 and 3 are phase 2 concerns; item 1 also helps phase 1.
|
||||||
@@ -0,0 +1,348 @@
|
|||||||
|
# Post-quantum handshakes
|
||||||
|
|
||||||
|
Status: draft. Decisions below were made on 2026-10-13; open items are listed at the end.
|
||||||
|
Phase 1 is implemented (see [Implementation](#implementation-phase-1)).
|
||||||
|
|
||||||
|
## Goals
|
||||||
|
|
||||||
|
1. **Confidentiality against harvest-now-decrypt-later.** Traffic recorded today must stay
|
||||||
|
secret after a cryptographically relevant quantum computer exists. This needs a
|
||||||
|
post-quantum key exchange now.
|
||||||
|
2. **Post-quantum authentication, later.** Needs certificates whose CA signature and host
|
||||||
|
keys are post-quantum. This requires reissuing certificates, so it ships second.
|
||||||
|
3. **Never rely on IP fragmentation.** ML-KEM and ML-DSA do not fit in one packet, so the
|
||||||
|
handshake must carry messages larger than the path MTU itself.
|
||||||
|
|
||||||
|
Non-goals: identity hiding beyond what IX offers today, and signatures at handshake time.
|
||||||
|
The only signature in the system stays the CA signature inside the certificate.
|
||||||
|
|
||||||
|
## Primitives and sizes
|
||||||
|
|
||||||
|
| Primitive | Size |
|
||||||
|
|---|---|
|
||||||
|
| ML-KEM-1024 encapsulation key | 1568 B |
|
||||||
|
| ML-KEM-1024 ciphertext | 1568 B |
|
||||||
|
| ML-DSA-87 public key / signature | 2592 B / 4627 B |
|
||||||
|
| Today's IX msg1 / msg2 (v2 cert, 151 B) | 252 B / 287 B |
|
||||||
|
|
||||||
|
`crypto/mlkem` is available in Go 1.26 (the current `go.mod`); `crypto/mldsa` arrives in
|
||||||
|
Go 1.27 and is only needed for phase 2.
|
||||||
|
|
||||||
|
## Phase 1: ephemeral ML-KEM on today's certificates
|
||||||
|
|
||||||
|
A new handshake subtype, `ix_psk2_mlkem1024` (2), IX-shaped (2 messages; the responder
|
||||||
|
completes on msg1 as today), using the flynn/noise `psk2` modifier. The Noise protocol name
|
||||||
|
becomes `Noise_IXpsk2_...`, which separates it from the classical subtype.
|
||||||
|
|
||||||
|
- **msg1**: the initiator generates a fresh ML-KEM-1024 key pair and places the
|
||||||
|
encapsulation key in `NebulaHandshakeDetails.KEMKey` (field 9). msg1's payload is mixed
|
||||||
|
into the Noise transcript, so it cannot be stripped or replaced without msg2 failing.
|
||||||
|
With the psk modifier Noise also mixes `e` into the cipher key, so msg1's static key and
|
||||||
|
payload are encrypted, though only under a key derived from the public ephemeral.
|
||||||
|
- **Responder**: after `ReadMessage(msg1)` it encapsulates to that key, obtaining
|
||||||
|
`(ct, ss)`, and calls `HandshakeState.SetPresharedKey(psk)` before writing msg2, with
|
||||||
|
`psk = HKDF-Extract(SHA-256, salt = "nebula ix_psk2_mlkem1024 v1", ikm = ss || ct)`.
|
||||||
|
The ciphertext is bound in because, unlike the encapsulation key, it is not part of the
|
||||||
|
Noise transcript.
|
||||||
|
- **msg2** on the wire is `ct || noise_msg2`. The ciphertext travels outside the Noise
|
||||||
|
message because the initiator needs `ss` before processing msg2's `psk` token. Any change
|
||||||
|
to `ct` yields a different `ss` (ML-KEM implicit rejection) and the handshake fails.
|
||||||
|
|
||||||
|
Transport keys depend on both the X25519 DH outputs and the ML-KEM shared secret.
|
||||||
|
Authentication is unchanged and classical. With a minimal v2 certificate msg1 and msg2 are
|
||||||
|
about 1.84 KB each, so each travels as 2 data and 2 repair fragments of about 936 bytes.
|
||||||
|
A KEM key on the classical subtype, or a missing or malformed one on this subtype, is a fatal
|
||||||
|
protocol error; a forged ciphertext only fails that packet.
|
||||||
|
|
||||||
|
## Phase 2: pqIX hybrid with certificate v3
|
||||||
|
|
||||||
|
Certificate v3 is hybrid: the classical static key and CA signature plus a static
|
||||||
|
ML-KEM-1024 key and an ML-DSA-87 CA signature. Host authentication is by KEM rather than by
|
||||||
|
signature, following PQNoise's pqIX, while keeping the classical DH tokens:
|
||||||
|
|
||||||
|
- **msg1** (I to R): `e, s`, ephemeral ML-KEM key, initiator cert.
|
||||||
|
- **msg2** (R to I): `e, s`, ciphertext to I's ephemeral KEM key, ciphertext to I's static
|
||||||
|
KEM key, responder cert.
|
||||||
|
- **msg3** (I to R): ciphertext to R's static KEM key, plus first data. R authenticates I
|
||||||
|
when msg3 decrypts; I authenticates R implicitly when R's first reply decrypts.
|
||||||
|
|
||||||
|
msg3 is about 1.6 KB, 2 data and 2 repair fragments, and adds no new message types:
|
||||||
|
|
||||||
|
- **Responder.** After sending msg2 the responder keeps a pending Machine, found by its
|
||||||
|
local index like the initiator's today; this is the multi-message responder support the
|
||||||
|
manager lacks now. A repeat msg1 maps to it through the answered-msg1 cache and gets msg2
|
||||||
|
resent with fresh symbols, exactly as in phase 1. Until msg3 verifies, data for that
|
||||||
|
index is dropped silently: it must not draw a RecvError, which would tear down the
|
||||||
|
initiator's new tunnel. On completing it sends an empty `Test`/`TestReply` under the
|
||||||
|
new keys, so the initiator hears back even when there is no traffic.
|
||||||
|
- **Initiator.** Writing msg3 yields the transport keys, so the hostinfo moves to the main
|
||||||
|
hostmap and data flows at once, readable only by the real responder. The handshake entry
|
||||||
|
stays behind in a confirming state: each retry tick resends msg3 with fresh symbols until
|
||||||
|
any packet from the responder decrypts on the new tunnel, and if that never happens
|
||||||
|
within the handshake timeout the tunnel is torn down. Losing msg3 costs the data sent
|
||||||
|
behind it, which the overlay's own transport retransmits.
|
||||||
|
- msg3's fragments use the responder's index as RemoteIndex and land on the responder's
|
||||||
|
pending entry, so they never enter the pre-authentication table.
|
||||||
|
|
||||||
|
The initiator never caches the responder's certificate, so every handshake has three
|
||||||
|
messages and carries both full certificates. With ML-DSA-87:
|
||||||
|
|
||||||
|
| Message | Size | Data fragments (k) |
|
||||||
|
|---|---|---|
|
||||||
|
| msg1 | ~8.2 KB | 8 |
|
||||||
|
| msg2 | ~9.8 KB | 9 |
|
||||||
|
| msg3 | ~1.6 KB | 2 |
|
||||||
|
|
||||||
|
flynn/noise cannot mix multiple KEM secrets into the chaining key, so phase 2 needs a
|
||||||
|
KEM-aware Noise symmetric state written in this repository. Both subtypes coexist.
|
||||||
|
|
||||||
|
Cryptographic review of the hybrid composition will be done by in-house cryptographers.
|
||||||
|
|
||||||
|
## Fragment transport
|
||||||
|
|
||||||
|
### Requirements
|
||||||
|
|
||||||
|
- No IP fragmentation: every datagram's UDP payload is at most 1232 bytes **after** relay
|
||||||
|
wrapping (16 B header + 16 B tag), the IPv6 minimum MTU budget also used by DNS Flag Day
|
||||||
|
2020 and Solana's Turbine.
|
||||||
|
- Every fragment of a handshake uses the same 5-tuple.
|
||||||
|
- Bounded pre-authentication state, bounded amplification, selective loss recovery,
|
||||||
|
tolerance of reordering and duplication, and a strictly validated, fuzzable parser.
|
||||||
|
|
||||||
|
### Wire format
|
||||||
|
|
||||||
|
Every packet of a fragmented handshake subtype is:
|
||||||
|
|
||||||
|
```
|
||||||
|
Nebula header (16) Version | Type=Handshake | Subtype | Reserved=0 | RemoteIndex | Counter
|
||||||
|
Fragment header (8) FragID u32 | MsgLen u16 | Index u8 | Flags u8
|
||||||
|
Cookie (16) only when Flags has 0x01
|
||||||
|
Symbol SymbolSize bytes
|
||||||
|
```
|
||||||
|
|
||||||
|
- `Counter` is the Noise message number (1, 2, 3). `RemoteIndex` is 0 for msg1, as today.
|
||||||
|
- `FragID` is the sender's local index (random, non-zero).
|
||||||
|
- `MsgLen` is the length of the whole message. Both ends derive the layout from it:
|
||||||
|
`K = ceil(MsgLen / 1160)`, `SymbolSize = ceil(MsgLen / K)`. Every symbol has the same
|
||||||
|
size. Room for a cookie is always reserved, so a packet is at most
|
||||||
|
16 + 8 + 16 + 1160 = 1200 bytes with or without one.
|
||||||
|
- `Index < K` is a data symbol (a slice of the message, the last one zero padded);
|
||||||
|
`Index >= K` is a repair symbol.
|
||||||
|
- `Flags` bit 0x01 means a cookie follows the fragment header. Other bits must be zero.
|
||||||
|
|
||||||
|
A cookie reply, sent by a responder under load, is a bare 32 byte packet:
|
||||||
|
|
||||||
|
```
|
||||||
|
Nebula header (16) Version | Type=Handshake | Subtype | Reserved=0 | RemoteIndex=FragID | Counter=0
|
||||||
|
Cookie (16)
|
||||||
|
```
|
||||||
|
|
||||||
|
It names the initiator's FragID, so the initiator finds its attempt the same way it finds
|
||||||
|
msg2.
|
||||||
|
|
||||||
|
### Forward error correction
|
||||||
|
|
||||||
|
Messages are protected with a systematic Reed-Solomon code over GF(2^8), implemented in
|
||||||
|
`handshake/fec`:
|
||||||
|
|
||||||
|
- The repair rows form a Cauchy matrix, `coefficient(row, col) = 1 / (row XOR col)` with
|
||||||
|
`row >= K > col`, so every square submatrix is invertible and **any K distinct symbols
|
||||||
|
reconstruct the message**. Naive identity-over-Vandermonde constructions are not MDS
|
||||||
|
(the PAR1 flaw and the 1997 Plank tutorial erratum).
|
||||||
|
- A repair row depends only on its index, so repair symbols are generated on demand and
|
||||||
|
their indexes never need to be agreed in advance. Up to 256 symbols exist per message.
|
||||||
|
- Known-answer vectors in `fec_test.go` pin the encoding and were cross-checked against an
|
||||||
|
independent implementation; changing them is a wire format change.
|
||||||
|
- Cost for a 9.8 KB message (k=9): about 13 µs for three repair symbols, about 19 µs to
|
||||||
|
decode with three data symbols missing.
|
||||||
|
|
||||||
|
**The sender chooses m**, the number of repair symbols per attempt. The receiver only needs
|
||||||
|
any K symbols, so this is policy and can change without a protocol change. The starting
|
||||||
|
rule is `m = max(2, ceil(K/3))`.
|
||||||
|
|
||||||
|
**Retries send fresh symbols.** Attempt 0 sends indexes `0 .. K+m-1`; each retry sends
|
||||||
|
the next `K+m` unused indexes. The receiver merges all distinct symbols across attempts,
|
||||||
|
so no received fragment is wasted. Indexes are a deterministic function of the message,
|
||||||
|
so retransmits stay idempotent: the responder caches msg2 itself and regenerates any
|
||||||
|
symbol.
|
||||||
|
|
||||||
|
**Repair symbols trail the data.** Data symbols go out back to back; repair symbols follow
|
||||||
|
after a short delay, so a queue tail-drop at the end of the data run does not also take the
|
||||||
|
repair. In simulation this lifts small messages substantially (k=2 at 10% loss, burst 8:
|
||||||
|
91.4% to 98.2% first-attempt success). Pacing every fragment was also evaluated; it gains
|
||||||
|
about 5 more points for k=7..9 on bursty paths, which is not worth the extra machinery,
|
||||||
|
and the retry with fresh symbols covers the remainder.
|
||||||
|
|
||||||
|
### Receiver rules
|
||||||
|
|
||||||
|
Implemented in `handshake/fragment` (`Sender`, `Assembly`, and the capped `Table`).
|
||||||
|
|
||||||
|
- Fragments are stored individually as they arrive and charged against a memory cap.
|
||||||
|
Nothing is allocated from a claimed size alone (FragmentSmack, game-engine "fragment
|
||||||
|
bombs").
|
||||||
|
- `MsgLen` must be identical for every fragment of a `FragID`; a mismatch drops the whole
|
||||||
|
entry. msg1 is capped at `MsgLen <= 16384` (K <= 15).
|
||||||
|
- The decoder keeps at most K distinct symbols, so an entry never exceeds about MsgLen bytes
|
||||||
|
however many repair symbols arrive.
|
||||||
|
- When K symbols are present the message is decoded and handed to the handshake `Machine`
|
||||||
|
as a synthetic `[header | message]`. The Machine never sees fragments.
|
||||||
|
- A completed entry is forgotten immediately. A late duplicate fragment starts a new entry
|
||||||
|
and, once enough arrive, reconstructs the same message again; the handshake layer's
|
||||||
|
duplicate detection recognises it.
|
||||||
|
- If Noise rejects a decoded message, the entry is discarded and the next attempt
|
||||||
|
supplies fresh symbols. (Possible refinement: keep a few spare symbols so an injected
|
||||||
|
bad symbol can be identified by re-encoding instead of waiting for a retry.)
|
||||||
|
- Pre-authentication msg1 entries live in a table keyed by (source address or relay index,
|
||||||
|
FragID) with a total memory cap, per-source quotas (/32 for IPv4, /64 for IPv6), a
|
||||||
|
sliding TTL of about 2 s refreshed by progress, and random eviction under pressure.
|
||||||
|
msg2 and msg3 reassembly attaches to the existing pending handshake found by RemoteIndex.
|
||||||
|
|
||||||
|
### Retransmission and amplification
|
||||||
|
|
||||||
|
- Only timers cause transmission. Reactive resends (the responder resending its cached
|
||||||
|
msg2 when a duplicate msg1 completes) are rate limited to one per handshake per retry
|
||||||
|
interval, to avoid TFTP's Sorcerer's Apprentice amplification.
|
||||||
|
- Duplicate msg1 detection compares the decoded message to the cached one **before**
|
||||||
|
running Noise or certificate verification.
|
||||||
|
- Before an address is validated, a responder sends at most 3x the bytes it received from
|
||||||
|
it (QUIC's rule). Normal handshakes sit near 1.1-1.2x.
|
||||||
|
- In phase 2 the initiator retransmits msg3 until any authenticated packet arrives from
|
||||||
|
the responder; the responder sends a small confirmation on completion and holds tunnel
|
||||||
|
traffic until msg3 verifies.
|
||||||
|
|
||||||
|
### Denial of service
|
||||||
|
|
||||||
|
The responder can no longer complete statelessly on msg1, since msg1 arrives in pieces.
|
||||||
|
Defenses are the capped table above plus a **cookie under load**, in the style of
|
||||||
|
WireGuard's mac2, QUIC Retry and the SCTP state cookie:
|
||||||
|
|
||||||
|
- Once the msg1 table is at least half full (by bytes or by entries), every msg1 fragment
|
||||||
|
must carry a valid cookie. One without is answered with a cookie reply and leaves no
|
||||||
|
state. Fragments that already belong to an entry need one too, so an attacker cannot
|
||||||
|
hold old entries open.
|
||||||
|
- A cookie is `HMAC-SHA256(secret, source address and port, relay channel, FragID)`
|
||||||
|
truncated to 16 bytes. The secret rotates every 2 minutes and the previous one is still
|
||||||
|
accepted, so a cookie is good for 2 to 4 minutes.
|
||||||
|
- Replies are never larger than the packet that prompted them (no amplification) and are
|
||||||
|
rate limited as a whole (a burst of 256, then 1000 per second), so spoofed floods cannot
|
||||||
|
turn the responder into a reflector.
|
||||||
|
- The initiator attaches the cookie to its PQ attempt, so every later packet carries it,
|
||||||
|
and immediately resends fresh symbols to the address the reply came from, at most once
|
||||||
|
per retry interval. Under load a PQ handshake costs one extra round trip, which in
|
||||||
|
practice still beats the classical attempt on the next retry tick.
|
||||||
|
- An attacker on the path can forge a cookie reply; the bogus cookie is simply rejected
|
||||||
|
and answered with a real one.
|
||||||
|
|
||||||
|
A CA-keyed pre-filter MAC was considered and rejected: networks commonly trust many CAs.
|
||||||
|
|
||||||
|
#### Injected symbols
|
||||||
|
|
||||||
|
The decoder keeps the first K distinct symbols it sees, so one forged symbol in those K
|
||||||
|
spoils that attempt's decode; Noise rejects the result and the next attempt brings fresh
|
||||||
|
symbols. Forging one needs the attempt's FragID or index, which are random 32 bit values,
|
||||||
|
and for msg1 the initiator's exact address and port too, so in practice only an attacker
|
||||||
|
who sees the traffic can do it. An attacker who can also drop packets gains nothing new.
|
||||||
|
One who can only inject, and races a forged symbol into every attempt, can stop a PQ
|
||||||
|
handshake where it could not stop a classical one, since classical msg2s are tried one
|
||||||
|
packet at a time. Keeping spare symbols to find a consistent subset only raises the number
|
||||||
|
of forgeries needed per attempt, and authenticating symbols is impossible for msg1, which
|
||||||
|
travels before any key exists. So the decoder deliberately does neither. A non-sticky
|
||||||
|
initiator still gets a classical tunnel from its next attempt; a sticky one, by design,
|
||||||
|
does not downgrade.
|
||||||
|
|
||||||
|
## Rollout
|
||||||
|
|
||||||
|
- Separate settings for initiating and accepting PQ handshakes, both off by default:
|
||||||
|
`handshakes.pq.initiate`, `handshakes.pq.accept`. `handshakes.pq.repair_delay` (default
|
||||||
|
10ms) sets how long repair fragments trail the data fragments.
|
||||||
|
- `handshakes.pq.require` makes every handshake PQ: it implies `initiate` and `accept`,
|
||||||
|
never offers a classical attempt, and drops classical msg1s.
|
||||||
|
- Old nodes silently drop unknown subtypes, so discovery is speculative: an initiator with
|
||||||
|
`initiate` enabled alternates PQ and classical attempts on successive timer retries,
|
||||||
|
keeping both pending, and the first to complete wins. A path nothing has been sent over
|
||||||
|
yet gets the PQ attempt first: an early resend triggered by a lighthouse reply is PQ, and
|
||||||
|
a relay that comes up pushes the PQ attempt through at once, counting as the PQ turn.
|
||||||
|
Without that, relays set up during the first attempt handed every relayed handshake to
|
||||||
|
the classical retry (seen on real hosts: 11 of 11). Once a msg2 fragment or cookie reply
|
||||||
|
arrives for the PQ attempt the peer evidently speaks PQ, and classical stops getting
|
||||||
|
turns.
|
||||||
|
- All `handshakes.pq` settings reload without a restart. Handshakes in flight carry on;
|
||||||
|
the new settings apply to the next attempt and the next packet.
|
||||||
|
- `handshakes.pq.sticky` (default off): once a peer has completed a PQ handshake, never fall
|
||||||
|
back to classical for it again during this process lifetime. This resists active
|
||||||
|
downgrade after first contact.
|
||||||
|
- No lighthouse capability advertisement.
|
||||||
|
|
||||||
|
## Simulation results
|
||||||
|
|
||||||
|
Gilbert-Elliott channel (bad state drops everything), losses expressed as average rate and
|
||||||
|
mean burst length in packets. First-attempt success for the whole handshake with
|
||||||
|
`m = max(2, ceil(K/3))` and repair delayed 16 packet slots, compared with no FEC:
|
||||||
|
|
||||||
|
| Handshake | Loss | Burst 1 | Burst 2 | Burst 4 | Burst 8 |
|
||||||
|
|---|---|---|---|---|---|
|
||||||
|
| phase 1 (2, 2) no FEC | 5% | 81.4% | 85.6% | 87.9% | 89.0% |
|
||||||
|
| phase 1 (2, 2) FEC | 5% | 99.9% | 99.4% | 99.3% | 98.6% |
|
||||||
|
| phase 1 (2, 2) FEC | 10% | 99.3% | 97.5% | 97.4% | 96.3% |
|
||||||
|
| phase 2 (8, 9, 2) no FEC | 5% | 37.8% | 56.0% | 69.3% | 77.1% |
|
||||||
|
| phase 2 (8, 9, 2) FEC | 5% | 99.6% | 93.7% | 89.9% | 88.4% |
|
||||||
|
| phase 2 (8, 9, 2) FEC | 10% | 95.3% | 83.5% | 77.9% | 76.7% |
|
||||||
|
|
||||||
|
With fresh repair symbols, phase 2 completes within two attempts at least 99.1% of the time
|
||||||
|
in every scenario above, and within three at least 99.98%.
|
||||||
|
|
||||||
|
The simulators and their outputs are in [pq-handshake-sim](pq-handshake-sim/README.md),
|
||||||
|
including a comparison with classical handshakes and a model of time to a working tunnel
|
||||||
|
under Nebula's retry schedule.
|
||||||
|
|
||||||
|
## Prior art
|
||||||
|
|
||||||
|
- **WireGuard / Rosenpass**: fit every message in one packet; cookies and biscuits for
|
||||||
|
statelessness. Not possible at our sizes.
|
||||||
|
- **IKEv2**: RFC 7383 fragments only after keys exist, with each fragment authenticated;
|
||||||
|
RFC 9242/9370 move PQ key exchange into intermediate exchanges for that reason.
|
||||||
|
- **QUIC / DTLS 1.3**: offset-based reassembly with ACKs; QUIC's 3x amplification limit and
|
||||||
|
1200-byte floor.
|
||||||
|
- **Solana Turbine**: Reed-Solomon over 1232-byte UDP packets through untrusted relays;
|
||||||
|
moved to Merkle-authenticated shreds after unauthenticated repair symbols enabled
|
||||||
|
poisoning.
|
||||||
|
- **kcp-go, UDPspeeder, CM256**: RS FEC over UDP; parity must scale up for small groups.
|
||||||
|
- **gQUIC FEC (removed)**: FEC does not pay for bulk transfer under bursty loss; it does
|
||||||
|
for short, latency-critical transfers such as handshakes.
|
||||||
|
- **TFTP, NFS duplicate request cache, memcached UDP, IP reassembly bugs**: retransmit
|
||||||
|
storms, ID-wrap misassembly, reflection amplification, and allocation from claimed sizes.
|
||||||
|
|
||||||
|
## Implementation (phase 1)
|
||||||
|
|
||||||
|
- `handshake`: the `ix_psk2_mlkem1024` subtype (`patterns.go`, `kem.go`), the `KEMKey`
|
||||||
|
payload field, and the psk2 plumbing in `Machine`.
|
||||||
|
- `handshake/fec`, `handshake/fragment`: the code and the fragment transport.
|
||||||
|
- `handshake_manager_pq.go` and the manager:
|
||||||
|
- **Initiator.** Attempts alternate PQ and classical, starting with PQ (sticky peers get
|
||||||
|
only PQ). The PQ attempt has its own local index registered alongside the classical
|
||||||
|
one; whichever response completes first wins, and the other index is released
|
||||||
|
(`settleIndex`). A timed out or deleted pending handshake releases both.
|
||||||
|
- **Responder.** msg1 fragments go into the capped pre-authentication table. A decoded
|
||||||
|
msg1 is looked up by hash among recently answered ones before any Noise, KEM or
|
||||||
|
certificate work: the trailing repair fragments of an attempt rebuild a msg1 its data
|
||||||
|
fragments already completed, and a retrying initiator offers fresh symbols for the
|
||||||
|
same msg1. A repeat goes straight to the cached-response resend, which offers fresh
|
||||||
|
msg2 symbols, is rate limited to one per retry interval and is held to the 3x
|
||||||
|
amplification budget.
|
||||||
|
- **Relays** carry fragments unchanged; repair fragments trail via a timer.
|
||||||
|
- The pre-authentication table is capped at 4 MiB, 1024 entries, 4 per source (IPv4 /32,
|
||||||
|
IPv6 /64, or relay channel), 16 KiB messages and a 3 s idle timeout. Cookies are
|
||||||
|
demanded from half full.
|
||||||
|
- Tests: Noise-level KEM tests, codec and fragment tests and fuzzers, manager unit tests
|
||||||
|
for the response budget and rate limit, and e2e tests for a clean handshake, loss of
|
||||||
|
data fragments in both directions, fallback to a peer that does not accept PQ, a lost
|
||||||
|
msg2 recovered by fresh symbols, sticky mode under an attacker dropping PQ packets,
|
||||||
|
relays, index cleanup on completion, fallback and timeout, and a responder flooded from
|
||||||
|
spoofed sources demanding and accepting a cookie. Unit tests cover cookie binding and
|
||||||
|
rotation, the never-amplify rule, the initiator's rate limited resend, and reload. ML-KEM and HKDF also
|
||||||
|
pass under `GOEXPERIMENT=boringcrypto` and `GODEBUG=fips140=on`.
|
||||||
|
|
||||||
|
## Open items
|
||||||
|
|
||||||
|
None for phase 1. Phase 2 needs certificate v3, the KEM-aware Noise symmetric state, and
|
||||||
|
the msg3 design above.
|
||||||
@@ -1,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
@@ -1,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
@@ -1,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
+2
-5
@@ -1,18 +1,15 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"io"
|
"log/slog"
|
||||||
"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"
|
||||||
@@ -382,7 +379,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.NewTextHandler(io.Discard, nil))
|
return slog.New(slog.DiscardHandler)
|
||||||
}
|
}
|
||||||
|
|
||||||
level := slog.LevelInfo
|
level := slog.LevelInfo
|
||||||
|
|||||||
@@ -1,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,476 @@
|
|||||||
|
//go:build e2e_testing
|
||||||
|
|
||||||
|
package e2e
|
||||||
|
|
||||||
|
import (
|
||||||
|
"net/netip"
|
||||||
|
"sync"
|
||||||
|
"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/handshake/fragment"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
"github.com/slackhq/nebula/udp"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
)
|
||||||
|
|
||||||
|
func pqRequire() m {
|
||||||
|
return m{"handshakes": m{"pq": m{"require": true, "repair_delay": "0s"}}}
|
||||||
|
}
|
||||||
|
|
||||||
|
func pqConfig(initiate, accept, sticky bool) m {
|
||||||
|
return m{"handshakes": m{"pq": m{
|
||||||
|
"initiate": initiate,
|
||||||
|
"accept": accept,
|
||||||
|
"sticky": sticky,
|
||||||
|
"repair_delay": "0s",
|
||||||
|
}}}
|
||||||
|
}
|
||||||
|
|
||||||
|
// handshakeOf returns the handshake header p carries, looking inside relay
|
||||||
|
// wrapping, plus the fragment header when the handshake is fragmented.
|
||||||
|
func handshakeOf(p *udp.Packet) (*header.H, *fragment.Header) {
|
||||||
|
b := p.Data
|
||||||
|
h := &header.H{}
|
||||||
|
if h.Parse(b) != nil {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
if h.Type == header.Message && h.Subtype == header.MessageRelay {
|
||||||
|
// Relays authenticate but do not encrypt the inner packet.
|
||||||
|
b = b[header.Len:]
|
||||||
|
if h.Parse(b) != nil {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if h.Type != header.Handshake {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
if !header.IsFragmented(h.Subtype) {
|
||||||
|
return h, nil
|
||||||
|
}
|
||||||
|
// A relayed packet still has the relay's AEAD tag on the end.
|
||||||
|
for _, tag := range []int{0, 16} {
|
||||||
|
if len(b) < header.Len+tag {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
if fh, _, err := fragment.Parse(b[header.Len : len(b)-tag]); err == nil {
|
||||||
|
return h, &fh
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return h, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// handshakeTally counts handshake packets by style as the router moves them.
|
||||||
|
type handshakeTally struct {
|
||||||
|
sync.Mutex
|
||||||
|
pq, classical int
|
||||||
|
maxPQLen int
|
||||||
|
}
|
||||||
|
|
||||||
|
func (ht *handshakeTally) observe(p *udp.Packet) {
|
||||||
|
h, _ := handshakeOf(p)
|
||||||
|
if h == nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
ht.Lock()
|
||||||
|
defer ht.Unlock()
|
||||||
|
if h.Subtype == header.HandshakeIXPSK2MLKEM1024 {
|
||||||
|
ht.pq++
|
||||||
|
ht.maxPQLen = max(ht.maxPQLen, len(p.Data))
|
||||||
|
} else {
|
||||||
|
ht.classical++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// isTunnelData reports whether p is ordinary tunnel traffic headed for to,
|
||||||
|
// directly or as the last hop of a relay.
|
||||||
|
func isTunnelData(p *udp.Packet, receiver, to *nebula.Control) bool {
|
||||||
|
h := &header.H{}
|
||||||
|
if receiver != to || h.Parse(p.Data) != nil || h.Type != header.Message {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if h.Subtype == header.MessageRelay {
|
||||||
|
if h.Parse(p.Data[header.Len:]) != nil {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return h.Type == header.Message && h.Subtype == header.MessageNone
|
||||||
|
}
|
||||||
|
|
||||||
|
func newPQPair(t *testing.T, mine, theirs m) (myControl, theirControl *nebula.Control, myVpn, theirVpn []netip.Prefix, myUdp, theirUdp netip.AddrPort, r *router.R) {
|
||||||
|
t.Helper()
|
||||||
|
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version2, cert.Curve_CURVE25519, time.Now(), time.Now().Add(10*time.Minute), nil, nil, []string{})
|
||||||
|
myControl, myVpn, myUdp, _ = newSimpleServer(cert.Version2, ca, caKey, "me", "10.128.0.1/24", mine)
|
||||||
|
theirControl, theirVpn, theirUdp, _ = newSimpleServer(cert.Version2, ca, caKey, "them", "10.128.0.2/24", theirs)
|
||||||
|
myControl.InjectLightHouseAddr(theirVpn[0].Addr(), theirUdp)
|
||||||
|
r = router.NewR(t, myControl, theirControl)
|
||||||
|
myControl.Start()
|
||||||
|
theirControl.Start()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPQHandshake(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
// They only accept, which is all a PQ initiator needs.
|
||||||
|
myControl, theirControl, myVpn, theirVpn, myUdp, theirUdp, r := newPQPair(t, pqConfig(true, true, false), pqConfig(false, true, false))
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(5*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
|
||||||
|
assertUdpPacket(t, []byte("Hi from me"), theirControl.GetFromTun(true), myVpn[0].Addr(), theirVpn[0].Addr(), 80, 80)
|
||||||
|
assert.Zero(t, tally.classical, "no classical handshake should be needed")
|
||||||
|
assert.GreaterOrEqual(t, tally.pq, 4, "both messages travel as several fragments")
|
||||||
|
assert.LessOrEqual(t, tally.maxPQLen, fragment.MaxPacketLen)
|
||||||
|
|
||||||
|
assertHostInfoPair(t, myUdp, theirUdp, myVpn, theirVpn, myControl, theirControl)
|
||||||
|
assertTunnel(t, myVpn[0].Addr(), theirVpn[0].Addr(), myControl, theirControl, r)
|
||||||
|
assert.Empty(t, myControl.ListHostmapIndexes(true), "no pending index may outlive the handshake")
|
||||||
|
assert.Empty(t, theirControl.ListHostmapIndexes(true))
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestPQHandshakeLoss drops data fragments of both messages; the repair
|
||||||
|
// fragments must carry the handshake without a retry.
|
||||||
|
func TestPQHandshakeLoss(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, _, r := newPQPair(t, pqConfig(true, true, false), pqConfig(false, true, false))
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
dropped := 0
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(5*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
if h, fh := handshakeOf(p); fh != nil {
|
||||||
|
// Every data fragment of msg1, and the first of msg2.
|
||||||
|
if (h.MessageCounter == 1 && int(fh.Index) < 2) || (h.MessageCounter == 2 && fh.Index == 0) {
|
||||||
|
dropped++
|
||||||
|
return router.Drop
|
||||||
|
}
|
||||||
|
}
|
||||||
|
tally.observe(p)
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
|
||||||
|
assertUdpPacket(t, []byte("Hi from me"), theirControl.GetFromTun(true), myVpn[0].Addr(), theirVpn[0].Addr(), 80, 80)
|
||||||
|
assert.Equal(t, 3, dropped)
|
||||||
|
assert.Zero(t, tally.classical, "the first attempt should succeed from repair fragments")
|
||||||
|
assertTunnel(t, myVpn[0].Addr(), theirVpn[0].Addr(), myControl, theirControl, r)
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestPQFallback has a peer that does not accept PQ handshakes. The initiator's
|
||||||
|
// next attempt is classical and the tunnel comes up anyway.
|
||||||
|
func TestPQFallback(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
myControl, theirControl, myVpn, theirVpn, myUdp, theirUdp, r := newPQPair(t, pqConfig(true, true, false), nil)
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(5*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
|
||||||
|
assertUdpPacket(t, []byte("Hi from me"), theirControl.GetFromTun(true), myVpn[0].Addr(), theirVpn[0].Addr(), 80, 80)
|
||||||
|
assert.Positive(t, tally.pq, "a PQ attempt comes first")
|
||||||
|
assert.Positive(t, tally.classical, "then a classical one")
|
||||||
|
|
||||||
|
assertHostInfoPair(t, myUdp, theirUdp, myVpn, theirVpn, myControl, theirControl)
|
||||||
|
assertTunnel(t, myVpn[0].Addr(), theirVpn[0].Addr(), myControl, theirControl, r)
|
||||||
|
assert.Empty(t, myControl.ListHostmapIndexes(true), "the losing PQ attempt's index must be released")
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestPQResendFreshSymbols loses the responder's whole first msg2. The
|
||||||
|
// initiator's next PQ attempt offers fresh msg1 symbols, the responder
|
||||||
|
// recognises the repeat and resends msg2 with symbols it has not sent before.
|
||||||
|
func TestPQResendFreshSymbols(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, _, r := newPQPair(t, pqConfig(true, true, false), pqConfig(false, true, false))
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var firstMsg2, freshMsg2, freshMsg1 int
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(10*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
h, fh := handshakeOf(p)
|
||||||
|
switch {
|
||||||
|
case h != nil && fh == nil:
|
||||||
|
// Keep the classical fallback out of the way.
|
||||||
|
return router.Drop
|
||||||
|
case fh != nil && h.MessageCounter == 2 && fh.Index < 4:
|
||||||
|
firstMsg2++
|
||||||
|
return router.Drop
|
||||||
|
case fh != nil && h.MessageCounter == 2:
|
||||||
|
freshMsg2++
|
||||||
|
case fh != nil && h.MessageCounter == 1 && fh.Index >= 4:
|
||||||
|
freshMsg1++
|
||||||
|
}
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
|
||||||
|
assertUdpPacket(t, []byte("Hi from me"), theirControl.GetFromTun(true), myVpn[0].Addr(), theirVpn[0].Addr(), 80, 80)
|
||||||
|
assert.Equal(t, 4, firstMsg2, "the first msg2 is 2 data and 2 repair fragments")
|
||||||
|
assert.Positive(t, freshMsg1, "the retry offers fresh msg1 symbols")
|
||||||
|
assert.Positive(t, freshMsg2, "the resend offers fresh msg2 symbols")
|
||||||
|
assertTunnel(t, myVpn[0].Addr(), theirVpn[0].Addr(), myControl, theirControl, r)
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestPQSticky checks a sticky initiator never offers a classical handshake to a
|
||||||
|
// peer it has already completed a PQ handshake with.
|
||||||
|
func TestPQSticky(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, _, r := newPQPair(t, pqConfig(true, true, true), pqConfig(false, true, false))
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(5*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
theirControl.GetFromTun(true)
|
||||||
|
|
||||||
|
t.Log("Rehandshake while an attacker drops every PQ packet")
|
||||||
|
var tally handshakeTally
|
||||||
|
myControl.ReHandshake(theirVpn[0].Addr())
|
||||||
|
r.RouteForAllExitFuncOrTimeout(time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
if h, _ := handshakeOf(p); h != nil && h.Subtype == header.HandshakeIXPSK2MLKEM1024 {
|
||||||
|
return router.Drop
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
})
|
||||||
|
assert.Positive(t, tally.pq, "PQ attempts keep being made")
|
||||||
|
assert.Zero(t, tally.classical, "sticky must never fall back")
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPQRelays(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
ca, _, caKey, _ := cert_test.NewTestCaCert(cert.Version1, cert.Curve_CURVE25519, time.Now(), time.Now().Add(10*time.Minute), nil, nil, []string{})
|
||||||
|
useRelays := pqConfig(true, true, false)
|
||||||
|
useRelays["relay"] = m{"use_relays": true}
|
||||||
|
amRelay := pqConfig(true, true, false)
|
||||||
|
amRelay["relay"] = m{"am_relay": true}
|
||||||
|
myControl, myVpnIpNet, _, _ := newSimpleServer(cert.Version1, ca, caKey, "me ", "10.128.0.1/24", useRelays)
|
||||||
|
relayControl, relayVpnIpNet, relayUdpAddr, _ := newSimpleServer(cert.Version1, ca, caKey, "relay ", "10.128.0.128/24", amRelay)
|
||||||
|
theirControl, theirVpnIpNet, theirUdpAddr, _ := newSimpleServer(cert.Version1, ca, caKey, "them ", "10.128.0.2/24", useRelays)
|
||||||
|
|
||||||
|
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()
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
var relayedPQ, relayedClassical int
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpnIpNet[0].Addr(), 80, myVpnIpNet[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(10*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
outer := &header.H{}
|
||||||
|
if outer.Parse(p.Data) == nil && outer.Type == header.Message && outer.Subtype == header.MessageRelay {
|
||||||
|
if h, fh := handshakeOf(p); h != nil && fh != nil {
|
||||||
|
relayedPQ++
|
||||||
|
assert.LessOrEqual(t, len(p.Data), fragment.MaxPacketLen+32, "a relayed fragment fits the IPv6 minimum MTU")
|
||||||
|
} else if h != nil {
|
||||||
|
relayedClassical++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
|
||||||
|
assertUdpPacket(t, []byte("Hi from me"), theirControl.GetFromTun(true), myVpnIpNet[0].Addr(), theirVpnIpNet[0].Addr(), 80, 80)
|
||||||
|
assert.Positive(t, relayedPQ, "the end to end handshake is PQ through the relay")
|
||||||
|
assert.Zero(t, relayedClassical, "the relay coming up carries the PQ attempt, not the classical retry")
|
||||||
|
r.RenderHostmaps("Final hostmaps", myControl, relayControl, theirControl)
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
relayControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestPQTimeoutReleasesIndexes lets a handshake with both a PQ and a classical
|
||||||
|
// attempt pending time out, and checks neither index is left behind.
|
||||||
|
func TestPQTimeoutReleasesIndexes(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
mine := pqConfig(true, true, false)
|
||||||
|
mine["handshakes"].(m)["retries"] = 2
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, _, r := newPQPair(t, mine, pqConfig(false, true, false))
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
r.RouteForAllExitFuncOrTimeout(1500*time.Millisecond, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
return router.Drop
|
||||||
|
})
|
||||||
|
|
||||||
|
assert.Positive(t, tally.pq)
|
||||||
|
assert.Positive(t, tally.classical)
|
||||||
|
assert.Nil(t, myControl.GetHostInfoByVpnAddr(theirVpn[0].Addr(), true), "the handshake should have timed out")
|
||||||
|
assert.Empty(t, myControl.ListHostmapIndexes(true))
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestPQCookieUnderLoad floods the responder with msg1 fragments from spoofed
|
||||||
|
// sources until it demands cookies, then checks a real initiator picks up the
|
||||||
|
// cookie and still completes a PQ handshake.
|
||||||
|
func TestPQCookieUnderLoad(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, theirUdp, r := newPQPair(t, pqConfig(true, true, false), pqConfig(false, true, false))
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
// Half of the 1024 entry table is the cookie threshold. Stopping exactly there
|
||||||
|
// keeps them from answering the spoofed sources, which the router cannot reach.
|
||||||
|
t.Log("Flood them with the first fragment of msg1s nobody will finish")
|
||||||
|
for i := range 512 {
|
||||||
|
from := netip.AddrPortFrom(netip.AddrFrom4([4]byte{198, 18, byte(i >> 8), byte(i)}), 4242)
|
||||||
|
s, err := fragment.NewSender(make([]byte, 2000), header.HandshakeIXPSK2MLKEM1024, 0, 1, uint32(i+1))
|
||||||
|
require.NoError(t, err)
|
||||||
|
pkts, _, err := s.Attempt(0)
|
||||||
|
require.NoError(t, err)
|
||||||
|
theirControl.InjectUDPPacket(&udp.Packet{From: from, To: theirUdp, Data: pkts[0]})
|
||||||
|
}
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
var cookieReplies, msg2, withCookie int
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(5*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
if h, fh := handshakeOf(p); h != nil && h.Subtype == header.HandshakeIXPSK2MLKEM1024 {
|
||||||
|
switch {
|
||||||
|
case h.MessageCounter == 0:
|
||||||
|
cookieReplies++
|
||||||
|
case h.MessageCounter == 2:
|
||||||
|
msg2++
|
||||||
|
case fh != nil && fh.HasCookie():
|
||||||
|
withCookie++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
|
||||||
|
assertUdpPacket(t, []byte("Hi from me"), theirControl.GetFromTun(true), myVpn[0].Addr(), theirVpn[0].Addr(), 80, 80)
|
||||||
|
assert.Positive(t, cookieReplies, "a loaded responder asks for a cookie")
|
||||||
|
assert.Positive(t, withCookie, "the initiator resends with it")
|
||||||
|
assert.Positive(t, msg2, "and the handshake completes post-quantum")
|
||||||
|
assert.Zero(t, tally.classical, "the cookie round trip beats the classical fallback")
|
||||||
|
assertTunnel(t, myVpn[0].Addr(), theirVpn[0].Addr(), myControl, theirControl, r)
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestPQRequire checks require mode never handshakes classically, in either
|
||||||
|
// direction.
|
||||||
|
func TestPQRequire(t *testing.T) {
|
||||||
|
t.Parallel()
|
||||||
|
|
||||||
|
t.Run("initiator", func(t *testing.T) {
|
||||||
|
// They neither speak PQ nor require it; we never fall back.
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, _, r := newPQPair(t, pqRequire(), nil)
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
r.RouteForAllExitFuncOrTimeout(time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
return router.KeepRouting
|
||||||
|
})
|
||||||
|
assert.Positive(t, tally.pq)
|
||||||
|
assert.Zero(t, tally.classical)
|
||||||
|
assert.Nil(t, theirControl.GetHostInfoByVpnAddr(myVpn[0].Addr(), false), "no tunnel without PQ")
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("responder", func(t *testing.T) {
|
||||||
|
// We only speak classical; they refuse it.
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, _, r := newPQPair(t, nil, pqRequire())
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var answers int
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
r.RouteForAllExitFuncOrTimeout(time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
if h, _ := handshakeOf(p); h != nil && h.MessageCounter == 2 {
|
||||||
|
answers++
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
})
|
||||||
|
assert.Zero(t, answers, "a classical msg1 gets no answer")
|
||||||
|
assert.Nil(t, theirControl.GetHostInfoByVpnAddr(myVpn[0].Addr(), false))
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("both", func(t *testing.T) {
|
||||||
|
myControl, theirControl, myVpn, theirVpn, _, _, r := newPQPair(t, pqRequire(), pqRequire())
|
||||||
|
defer r.RenderFlow()
|
||||||
|
|
||||||
|
var tally handshakeTally
|
||||||
|
myControl.InjectTunPacket(BuildTunUDPPacket(theirVpn[0].Addr(), 80, myVpn[0].Addr(), 80, []byte("Hi from me")))
|
||||||
|
require.True(t, r.RouteForAllExitFuncOrTimeout(5*time.Second, func(p *udp.Packet, receiver *nebula.Control) router.ExitType {
|
||||||
|
tally.observe(p)
|
||||||
|
if isTunnelData(p, receiver, theirControl) {
|
||||||
|
return router.RouteAndExit
|
||||||
|
}
|
||||||
|
return router.KeepRouting
|
||||||
|
}), "tunnel never came up")
|
||||||
|
assertUdpPacket(t, []byte("Hi from me"), theirControl.GetFromTun(true), myVpn[0].Addr(), theirVpn[0].Addr(), 80, 80)
|
||||||
|
assert.Zero(t, tally.classical)
|
||||||
|
assertTunnel(t, myVpn[0].Addr(), theirVpn[0].Addr(), myControl, theirControl, r)
|
||||||
|
|
||||||
|
myControl.Stop()
|
||||||
|
theirControl.Stop()
|
||||||
|
})
|
||||||
|
}
|
||||||
+57
-1
@@ -1,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
@@ -223,3 +222,60 @@ 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()
|
||||||
|
}
|
||||||
@@ -0,0 +1,135 @@
|
|||||||
|
//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,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package router
|
package router
|
||||||
|
|
||||||
|
|||||||
+22
-5
@@ -1,16 +1,17 @@
|
|||||||
//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"
|
||||||
@@ -22,7 +23,6 @@ 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,6 +153,9 @@ 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
|
||||||
@@ -163,7 +166,9 @@ 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())
|
||||||
|
|
||||||
if err := os.MkdirAll("mermaid", 0755); err != nil {
|
// t.Name() contains a slash for subtests, so the flow log can land in a nested directory
|
||||||
|
fn := filepath.Join("mermaid", fmt.Sprintf("%s.md", t.Name()))
|
||||||
|
if err := os.MkdirAll(filepath.Dir(fn), 0755); err != nil {
|
||||||
panic(err)
|
panic(err)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -174,7 +179,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: filepath.Join("mermaid", fmt.Sprintf("%s.md", t.Name())),
|
fn: fn,
|
||||||
t: t,
|
t: t,
|
||||||
cancelRender: cancel,
|
cancelRender: cancel,
|
||||||
}
|
}
|
||||||
@@ -369,7 +374,7 @@ func (r *R) RenderHostmaps(title string, controls ...*nebula.Control) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (r *R) renderHostmaps(title string) {
|
func (r *R) renderHostmaps(title string) {
|
||||||
c := maps.Values(r.controls)
|
c := slices.AppendSeq(make([]*nebula.Control, 0, len(r.controls)), 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
|
||||||
})
|
})
|
||||||
@@ -687,6 +692,10 @@ 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)
|
||||||
@@ -779,6 +788,10 @@ 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)
|
||||||
@@ -884,6 +897,10 @@ 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,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
@@ -1,5 +1,4 @@
|
|||||||
//go:build e2e_testing
|
//go:build e2e_testing
|
||||||
// +build e2e_testing
|
|
||||||
|
|
||||||
package e2e
|
package e2e
|
||||||
|
|
||||||
|
|||||||
+58
-7
@@ -131,13 +131,16 @@ 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
|
||||||
# Configure socket buffers for the udp side (outside), leave unset to use the system defaults. Values will be doubled by the kernel
|
# Linux only. 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: 10485760
|
read_buffer: 3412512
|
||||||
#write_buffer: 10485760
|
write_buffer: 3412512
|
||||||
|
|
||||||
# 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.
|
||||||
@@ -169,6 +172,8 @@ 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
|
||||||
@@ -257,11 +262,39 @@ 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 500
|
# 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
|
||||||
tx_queue: 500
|
tx_queue: 5000
|
||||||
# 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
|
||||||
|
|
||||||
# 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
|
||||||
@@ -378,13 +411,31 @@ logging:
|
|||||||
#try_interval: 100ms
|
#try_interval: 100ms
|
||||||
#retries: 20
|
#retries: 20
|
||||||
|
|
||||||
# query_buffer is the size of the buffer channel for querying lighthouses
|
# query_buffer is the size of the buffer channel for querying lighthouses, drops are recorded in the lighthouse.query.dropped metric.
|
||||||
#query_buffer: 64
|
#query_buffer: 1024
|
||||||
|
|
||||||
# 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
|
||||||
#trigger_buffer: 64
|
#trigger_buffer: 64
|
||||||
|
|
||||||
|
# pq enables handshakes that mix an ephemeral ML-KEM-1024 key exchange into the session keys, protecting
|
||||||
|
# recorded traffic against a future quantum computer. Authentication is unchanged. These handshakes are too
|
||||||
|
# large for one packet and travel as fragments with forward error correction.
|
||||||
|
#pq:
|
||||||
|
# initiate starts post-quantum handshakes. Attempts alternate between post-quantum and classical until one is
|
||||||
|
# answered, so peers that do not support them still connect.
|
||||||
|
#initiate: false
|
||||||
|
# accept answers post-quantum handshakes from peers.
|
||||||
|
#accept: false
|
||||||
|
# require makes every handshake post-quantum: it implies initiate and accept, never offers a classical handshake
|
||||||
|
# and refuses classical handshakes from peers. Only enable it once every host can speak post-quantum handshakes.
|
||||||
|
#require: false
|
||||||
|
# sticky never falls back to a classical handshake with a peer that has completed a post-quantum one since
|
||||||
|
# nebula started, which defeats an attacker who drops post-quantum handshakes to force a downgrade.
|
||||||
|
#sticky: false
|
||||||
|
# repair_delay is how long the forward error correction fragments trail the rest of a handshake message.
|
||||||
|
#repair_delay: 10ms
|
||||||
|
|
||||||
# Tunnel manager settings
|
# Tunnel manager settings
|
||||||
#tunnels:
|
#tunnels:
|
||||||
# drop_inactive controls whether inactive tunnels are maintained or dropped after the inactive_timeout period has
|
# drop_inactive controls whether inactive tunnels are maintained or dropped after the inactive_timeout period has
|
||||||
|
|||||||
+15
-14
@@ -21,6 +21,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/firewall"
|
"github.com/slackhq/nebula/firewall"
|
||||||
|
"github.com/slackhq/nebula/iputil"
|
||||||
)
|
)
|
||||||
|
|
||||||
type FirewallInterface interface {
|
type FirewallInterface interface {
|
||||||
@@ -262,11 +263,11 @@ func (f *Firewall) AddRule(incoming bool, proto uint8, startPort int32, endPort
|
|||||||
}
|
}
|
||||||
|
|
||||||
switch proto {
|
switch proto {
|
||||||
case firewall.ProtoTCP:
|
case iputil.IPProtocolTCP:
|
||||||
fp = ft.TCP
|
fp = ft.TCP
|
||||||
case firewall.ProtoUDP:
|
case iputil.IPProtocolUDP:
|
||||||
fp = ft.UDP
|
fp = ft.UDP
|
||||||
case firewall.ProtoICMP, firewall.ProtoICMPv6:
|
case iputil.IPProtocolICMP, iputil.IPProtocolICMPv6:
|
||||||
//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)
|
||||||
@@ -364,13 +365,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 = firewall.ProtoTCP
|
proto = iputil.IPProtocolTCP
|
||||||
startPort, endPort, err = parsePort(sPort)
|
startPort, endPort, err = parsePort(sPort)
|
||||||
case "udp":
|
case "udp":
|
||||||
proto = firewall.ProtoUDP
|
proto = iputil.IPProtocolUDP
|
||||||
startPort, endPort, err = parsePort(sPort)
|
startPort, endPort, err = parsePort(sPort)
|
||||||
case "icmp":
|
case "icmp":
|
||||||
proto = firewall.ProtoICMP
|
proto = iputil.IPProtocolICMP
|
||||||
startPort = firewall.PortAny
|
startPort = firewall.PortAny
|
||||||
endPort = firewall.PortAny
|
endPort = firewall.PortAny
|
||||||
if sPort != "" {
|
if sPort != "" {
|
||||||
@@ -560,9 +561,9 @@ func (f *Firewall) inConns(fp firewall.Packet, h *HostInfo, caPool *cert.CAPool,
|
|||||||
}
|
}
|
||||||
|
|
||||||
switch fp.Protocol {
|
switch fp.Protocol {
|
||||||
case firewall.ProtoTCP:
|
case iputil.IPProtocolTCP:
|
||||||
c.Expires = time.Now().Add(f.TCPTimeout)
|
c.Expires = time.Now().Add(f.TCPTimeout)
|
||||||
case firewall.ProtoUDP:
|
case iputil.IPProtocolUDP:
|
||||||
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)
|
||||||
@@ -582,9 +583,9 @@ func (f *Firewall) addConn(fp firewall.Packet, incoming bool) {
|
|||||||
c := &conn{}
|
c := &conn{}
|
||||||
|
|
||||||
switch fp.Protocol {
|
switch fp.Protocol {
|
||||||
case firewall.ProtoTCP:
|
case iputil.IPProtocolTCP:
|
||||||
timeout = f.TCPTimeout
|
timeout = f.TCPTimeout
|
||||||
case firewall.ProtoUDP:
|
case iputil.IPProtocolUDP:
|
||||||
timeout = f.UDPTimeout
|
timeout = f.UDPTimeout
|
||||||
default:
|
default:
|
||||||
timeout = f.DefaultTimeout
|
timeout = f.DefaultTimeout
|
||||||
@@ -635,15 +636,15 @@ func (ft *FirewallTable) match(p firewall.Packet, incoming bool, c *cert.CachedC
|
|||||||
}
|
}
|
||||||
|
|
||||||
switch p.Protocol {
|
switch p.Protocol {
|
||||||
case firewall.ProtoTCP:
|
case iputil.IPProtocolTCP:
|
||||||
if ft.TCP.match(p, incoming, c, caPool) {
|
if ft.TCP.match(p, incoming, c, caPool) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case firewall.ProtoUDP:
|
case iputil.IPProtocolUDP:
|
||||||
if ft.UDP.match(p, incoming, c, caPool) {
|
if ft.UDP.match(p, incoming, c, caPool) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
case firewall.ProtoICMP, firewall.ProtoICMPv6:
|
case iputil.IPProtocolICMP, iputil.IPProtocolICMPv6:
|
||||||
if ft.ICMP.match(p, incoming, c, caPool) {
|
if ft.ICMP.match(p, incoming, c, caPool) {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
@@ -680,7 +681,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 == firewall.ProtoICMP || p.Protocol == firewall.ProtoICMPv6 {
|
if p.Protocol == iputil.IPProtocolICMP || p.Protocol == iputil.IPProtocolICMPv6 {
|
||||||
// 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)
|
||||||
|
|||||||
+4
-2
@@ -5,6 +5,8 @@ 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
|
||||||
@@ -56,8 +58,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(), slog.LevelDebug) {
|
if c.l.Enabled(context.Background(), logging.LevelTrace) {
|
||||||
c.l.Debug("resetting conntrack cache", "len", ll)
|
c.l.Log(context.Background(), logging.LevelTrace, "resetting conntrack cache", "len", ll)
|
||||||
}
|
}
|
||||||
c.cache = make(ConntrackCache, ll)
|
c.cache = make(ConntrackCache, ll)
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -6,6 +6,7 @@ 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"
|
||||||
)
|
)
|
||||||
@@ -21,7 +22,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 := 0; i < cacheLen; i++ {
|
for i := range cacheLen {
|
||||||
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
|
||||||
@@ -30,27 +31,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, slog.LevelDebug)
|
l := test.NewLoggerWithOutputAndLevel(buf, logging.LevelTrace)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 3)
|
c := newFixedTicker(t, l, 3)
|
||||||
c.Get()
|
c.Get()
|
||||||
|
|
||||||
assert.Equal(t, "level=DEBUG msg=\"resetting conntrack cache\" len=3\n", buf.String())
|
assert.Equal(t, "level=DEBUG-4 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, slog.LevelDebug)
|
l := test.NewJSONLoggerWithOutput(buf, logging.LevelTrace)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 2)
|
c := newFixedTicker(t, l, 2)
|
||||||
c.Get()
|
c.Get()
|
||||||
|
|
||||||
assert.JSONEq(t, `{"level":"DEBUG","msg":"resetting conntrack cache","len":2}`, strings.TrimSpace(buf.String()))
|
assert.JSONEq(t, `{"level":"DEBUG-4","msg":"resetting conntrack cache","len":2}`, strings.TrimSpace(buf.String()))
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestConntrackCacheTicker_Get_QuietBelowDebug(t *testing.T) {
|
func TestConntrackCacheTicker_Get_QuietBelowTrace(t *testing.T) {
|
||||||
buf := &bytes.Buffer{}
|
buf := &bytes.Buffer{}
|
||||||
l := test.NewLoggerWithOutputAndLevel(buf, slog.LevelInfo)
|
l := test.NewLoggerWithOutputAndLevel(buf, slog.LevelDebug)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 5)
|
c := newFixedTicker(t, l, 5)
|
||||||
c.Get()
|
c.Get()
|
||||||
@@ -60,7 +61,7 @@ func TestConntrackCacheTicker_Get_QuietBelowDebug(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, slog.LevelDebug)
|
l := test.NewLoggerWithOutputAndLevel(buf, logging.LevelTrace)
|
||||||
|
|
||||||
c := newFixedTicker(t, l, 0)
|
c := newFixedTicker(t, l, 0)
|
||||||
c.Get()
|
c.Get()
|
||||||
|
|||||||
+15
-9
@@ -4,17 +4,14 @@ 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`
|
||||||
)
|
)
|
||||||
@@ -45,13 +42,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 ProtoTCP:
|
case iputil.IPProtocolTCP:
|
||||||
proto = "tcp"
|
proto = "tcp"
|
||||||
case ProtoICMP:
|
case iputil.IPProtocolICMP:
|
||||||
proto = "icmp"
|
proto = "icmp"
|
||||||
case ProtoICMPv6:
|
case iputil.IPProtocolICMPv6:
|
||||||
proto = "icmpv6"
|
proto = "icmpv6"
|
||||||
case ProtoUDP:
|
case iputil.IPProtocolUDP:
|
||||||
proto = "udp"
|
proto = "udp"
|
||||||
default:
|
default:
|
||||||
proto = fmt.Sprintf("unknown %v", fp.Protocol)
|
proto = fmt.Sprintf("unknown %v", fp.Protocol)
|
||||||
@@ -65,3 +62,12 @@ 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
|
||||||
|
}
|
||||||
+34
-33
@@ -13,6 +13,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/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"
|
||||||
@@ -72,20 +73,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, firewall.ProtoTCP, 1, 1, []string{}, "", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, iputil.IPProtocolTCP, 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, firewall.ProtoUDP, 1, 1, []string{"g1"}, "", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, iputil.IPProtocolUDP, 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, firewall.ProtoICMP, 1, 1, []string{}, "h1", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, iputil.IPProtocolICMP, 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)
|
||||||
@@ -116,11 +117,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, firewall.ProtoUDP, 1, 1, []string{"g1"}, "", "", "", "ca-name", ""))
|
require.NoError(t, fw.AddRule(true, iputil.IPProtocolUDP, 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, firewall.ProtoUDP, 1, 1, []string{"g1"}, "", "", "", "", "ca-sha"))
|
require.NoError(t, fw.AddRule(true, iputil.IPProtocolUDP, 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)
|
||||||
@@ -185,7 +186,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -263,7 +264,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -350,7 +351,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: firewall.ProtoUDP}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolUDP}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -360,7 +361,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: firewall.ProtoTCP, LocalPort: 1}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 1}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -370,7 +371,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: firewall.ProtoTCP, LocalPort: 100, LocalAddr: ip.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, 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) {
|
||||||
@@ -379,7 +380,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: firewall.ProtoTCP, LocalPort: 100, LocalAddr: ip.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: ip.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -392,7 +393,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: firewall.ProtoTCP, LocalPort: 10}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, 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) {
|
||||||
@@ -404,7 +405,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: firewall.ProtoTCP, LocalPort: 10}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 10}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -417,7 +418,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: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, 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) {
|
||||||
@@ -429,7 +430,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: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
assert.False(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -441,7 +442,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: firewall.ProtoTCP, LocalPort: 10}, true, c, cp))
|
assert.True(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 10}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -453,7 +454,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: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix.Addr()}, true, c, cp))
|
assert.True(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, 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) {
|
||||||
@@ -464,7 +465,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: firewall.ProtoTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
assert.True(b, ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 100, LocalAddr: pfix6.Addr()}, true, c, cp))
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
@@ -476,7 +477,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: firewall.ProtoTCP, LocalPort: 10}, true, c, cp)
|
ft.match(firewall.Packet{Protocol: iputil.IPProtocolTCP, LocalPort: 10}, true, c, cp)
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
@@ -492,7 +493,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -550,7 +551,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -638,7 +639,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -675,7 +676,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
network := netip.MustParsePrefix("1.2.3.4/24")
|
network := netip.MustParsePrefix("1.2.3.4/24")
|
||||||
@@ -758,13 +759,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: firewall.ProtoICMP,
|
Protocol: iputil.IPProtocolICMP,
|
||||||
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, firewall.ProtoICMP, 0, 0, []string{"any"}, "", "", "", "", ""))
|
require.NoError(t, fw.AddRule(true, iputil.IPProtocolICMP, 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
|
||||||
@@ -910,7 +911,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
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)
|
||||||
@@ -961,7 +962,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
}
|
}
|
||||||
|
|
||||||
require.NoError(t, fw.Drop(flow, true, &victimHI, cp, nil),
|
require.NoError(t, fw.Drop(flow, true, &victimHI, cp, nil),
|
||||||
@@ -1031,7 +1032,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
}
|
}
|
||||||
|
|
||||||
cases := []struct {
|
cases := []struct {
|
||||||
@@ -1317,28 +1318,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: firewall.ProtoTCP, startPort: 1, endPort: 1, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolTCP, 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: firewall.ProtoUDP, startPort: 1, endPort: 1, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolUDP, 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: firewall.ProtoICMP, startPort: firewall.PortAny, endPort: firewall.PortAny, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolICMP, 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: firewall.ProtoICMP, startPort: firewall.PortAny, endPort: firewall.PortAny, groups: nil, host: "a", ip: "", localIp: ""}, mf.lastCall)
|
assert.Equal(t, addRuleCall{incoming: false, proto: iputil.IPProtocolICMP, 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())
|
||||||
@@ -1582,7 +1583,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: firewall.ProtoUDP,
|
Protocol: iputil.IPProtocolUDP,
|
||||||
Fragment: false,
|
Fragment: false,
|
||||||
}
|
}
|
||||||
return testcase{
|
return testcase{
|
||||||
|
|||||||
@@ -5,35 +5,33 @@ 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/cyberdelia/go-metrics-graphite v0.0.0-20161219230853-39f87cc3b432
|
|
||||||
github.com/flynn/noise v1.1.0
|
github.com/flynn/noise v1.1.0
|
||||||
github.com/gaissmai/bart v0.28.0
|
github.com/gaissmai/bart v0.29.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.72
|
github.com/miekg/dns v1.1.73
|
||||||
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.23.2
|
github.com/prometheus/client_golang v1.24.1
|
||||||
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.11.1
|
github.com/stretchr/testify v1.12.1
|
||||||
github.com/vishvananda/netlink v1.3.1
|
|
||||||
go.uber.org/goleak v1.3.0
|
go.uber.org/goleak v1.3.0
|
||||||
go.yaml.in/yaml/v3 v3.0.4
|
go.yaml.in/yaml/v3 v3.0.5
|
||||||
golang.org/x/crypto v0.54.0
|
golang.org/x/crypto v0.57.0
|
||||||
golang.org/x/exp v0.0.0-20230725093048-515e97ebf090
|
golang.org/x/net v0.59.0
|
||||||
golang.org/x/net v0.57.0
|
golang.org/x/sync v0.23.0
|
||||||
golang.org/x/sync v0.22.0
|
golang.org/x/sys v0.48.0
|
||||||
golang.org/x/sys v0.47.0
|
golang.org/x/term v0.46.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.11
|
google.golang.org/protobuf v1.36.12
|
||||||
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
|
||||||
)
|
)
|
||||||
@@ -41,16 +39,11 @@ 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.66.1 // indirect
|
github.com/prometheus/common v0.70.1 // indirect
|
||||||
github.com/prometheus/procfs v0.16.1 // indirect
|
github.com/prometheus/procfs v0.21.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,6 +3,8 @@ dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
|
|||||||
dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
|
dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
|
||||||
filippo.io/bigmod v0.1.0 h1:UNzDk7y9ADKST+axd9skUpBQeW7fG2KrTZyOE4uGQy8=
|
filippo.io/bigmod v0.1.0 h1:UNzDk7y9ADKST+axd9skUpBQeW7fG2KrTZyOE4uGQy8=
|
||||||
filippo.io/bigmod v0.1.0/go.mod h1:OjOXDNlClLblvXdwgFFOQFJEocLhhtai8vGLy0JCZlI=
|
filippo.io/bigmod v0.1.0/go.mod h1:OjOXDNlClLblvXdwgFFOQFJEocLhhtai8vGLy0JCZlI=
|
||||||
|
github.com/DefinedNet/netlink v1.3.2-dn.1 h1:Md2PsUE1Xuy1Zxs/Bm6356n1kt5bq2HspXlPJ6pEspg=
|
||||||
|
github.com/DefinedNet/netlink v1.3.2-dn.1/go.mod h1:o4YSn8Jw7zoDcYXDmV77TRd4eS5sSLuE+vu2zAN67C8=
|
||||||
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
||||||
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
|
||||||
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
|
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
|
||||||
@@ -19,15 +21,12 @@ github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6r
|
|||||||
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||||
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/cyberdelia/go-metrics-graphite v0.0.0-20161219230853-39f87cc3b432 h1:M5QgkYacWj0Xs8MhpIK/5uwU02icXpEoSo9sM2aRCps=
|
|
||||||
github.com/cyberdelia/go-metrics-graphite v0.0.0-20161219230853-39f87cc3b432/go.mod h1:xwIwAxMvYnVrGJPe2FKx5prTrnAjGOD8zvDOnxnrrkM=
|
|
||||||
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.28.0 h1:89yZLo8NmyqD0RYgJ3QO9HhqqGGw+oWhf90cZm69Lko=
|
github.com/gaissmai/bart v0.29.0 h1:wO6HGE8g9YE0Wm0bCpYxwRzfQ4+fbJKOhL64e5ACGCI=
|
||||||
github.com/gaissmai/bart v0.28.0/go.mod h1:GREWQfTLRWz/c5FTOsIw+KkscuFkIV5t8Rp7Nd1Td5c=
|
github.com/gaissmai/bart v0.29.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=
|
||||||
@@ -70,23 +69,22 @@ 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.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
|
github.com/klauspost/compress v1.19.1 h1:VsB4HPswih7mmZ8WleSFQ75c/Ui1M4trX5oAsJnhSlk=
|
||||||
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
|
github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
|
||||||
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.72 h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI=
|
github.com/miekg/dns v1.1.73 h1:uhT8nJxmTrPJYClxVxTCX+CVn6qnzSiybRk72Z6DgrE=
|
||||||
github.com/miekg/dns v1.1.72/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs=
|
github.com/miekg/dns v1.1.73/go.mod h1:RW2Obtfd5NZHvOFe3zYG0W8koWOQtAzyHaLo8vASBuQ=
|
||||||
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=
|
||||||
@@ -102,14 +100,13 @@ 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.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
|
github.com/prometheus/client_golang v1.24.1 h1:JnJkREXzWxUdCuPFpIWZiPispT9xVV59uiuyR2bPlnU=
|
||||||
github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
|
github.com/prometheus/client_golang v1.24.1/go.mod h1:F+oSRECHg4sse5ucfYpYDeIv/hu68Zo0uoHKetWnzcE=
|
||||||
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=
|
||||||
@@ -118,18 +115,16 @@ 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.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
|
github.com/prometheus/common v0.70.1 h1:1HvjP4D5oL3t8RsPlwxA9onvvStjtIHYE5XuuwOi/PY=
|
||||||
github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
|
github.com/prometheus/common v0.70.1/go.mod h1:VdFUQDMZK3VLkurFUVhia6uys/0suUp86TJz5qbJRhc=
|
||||||
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.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
|
github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI=
|
||||||
github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
|
github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
|
||||||
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=
|
||||||
@@ -143,35 +138,29 @@ 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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
|
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
|
||||||
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
|
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
|
||||||
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.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
|
go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
|
||||||
go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
|
go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
|
||||||
go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
|
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
|
||||||
go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
|
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
|
||||||
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.54.0 h1:YLIA59K4fiNzHzjnZt2tUJQjQtUWfWbeHBqKtk3eScw=
|
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
|
||||||
golang.org/x/crypto v0.54.0/go.mod h1:KWL8ny2AZdGR2cWmzeHrp2azQPGogOv+HeQaVEXC2dk=
|
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
|
||||||
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=
|
||||||
@@ -182,8 +171,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.57.0 h1:K5+3DljvIuDG9/Jv9rvyMywYNFCQ9RSUY6OOTTkT+tE=
|
golang.org/x/net v0.59.0 h1:5zfYln+w5XCxwrnMMJPufRgNoXEaGxl0wo5GqPXyues=
|
||||||
golang.org/x/net v0.57.0/go.mod h1:KpXc8iv+r3XplLAG/f7Jsf9RPszJzdR0f58q9vGOuEU=
|
golang.org/x/net v0.59.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
|
||||||
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=
|
||||||
@@ -191,8 +180,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.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
|
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
|
||||||
golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
|
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
|
||||||
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=
|
||||||
@@ -206,13 +195,11 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w
|
|||||||
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||||
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||||
golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||||
golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
|
||||||
golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
|
||||||
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.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0=
|
golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE=
|
||||||
golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w=
|
golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc=
|
||||||
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=
|
||||||
@@ -223,8 +210,6 @@ 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=
|
||||||
@@ -243,8 +228,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.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
|
google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=
|
||||||
google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
|
google.golang.org/protobuf v1.36.12/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=
|
||||||
|
|||||||
+130
@@ -0,0 +1,130 @@
|
|||||||
|
package nebula
|
||||||
|
|
||||||
|
// This file is a trimmed, inlined copy of the graphite exporter from
|
||||||
|
// github.com/cyberdelia/go-metrics-graphite, retaining only the Config type and
|
||||||
|
// the Once entrypoint that Nebula uses. The upstream package has been
|
||||||
|
// unmaintained for 10+ years, so it was vendored here to drop the dependency.
|
||||||
|
// See https://github.com/slackhq/nebula/issues/1831.
|
||||||
|
//
|
||||||
|
// Copyright 2015 Timothée Peignier. All rights reserved.
|
||||||
|
//
|
||||||
|
// Redistribution and use in source and binary forms, with or without
|
||||||
|
// modification, are permitted provided that the following conditions are met:
|
||||||
|
//
|
||||||
|
// 1. Redistributions of source code must retain the above copyright notice,
|
||||||
|
// this list of conditions and the following disclaimer.
|
||||||
|
//
|
||||||
|
// 2. Redistributions in binary form must reproduce the above copyright notice,
|
||||||
|
// this list of conditions and the following disclaimer in the documentation
|
||||||
|
// and/or other materials provided with the distribution.
|
||||||
|
//
|
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||||
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||||
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||||
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||||
|
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||||
|
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||||
|
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||||
|
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||||
|
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bufio"
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
"net"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/rcrowley/go-metrics"
|
||||||
|
)
|
||||||
|
|
||||||
|
// graphiteConfigExport provides a container with configuration parameters for
|
||||||
|
// the Graphite exporter.
|
||||||
|
type graphiteConfigExport struct {
|
||||||
|
Addr *net.TCPAddr // Network address to connect to
|
||||||
|
Registry metrics.Registry // Registry to be exported
|
||||||
|
FlushInterval time.Duration // Flush interval
|
||||||
|
DurationUnit time.Duration // Time conversion unit for durations
|
||||||
|
Prefix string // Prefix to be prepended to metric names
|
||||||
|
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
|
||||||
|
// error if it could not connect or write all of it within timeout. It gives up
|
||||||
|
// as soon as ctx is done.
|
||||||
|
func graphiteOnce(ctx context.Context, c graphiteConfigExport, timeout time.Duration) error {
|
||||||
|
now := time.Now().Unix()
|
||||||
|
du := float64(c.DurationUnit)
|
||||||
|
flushSeconds := float64(c.FlushInterval) / float64(time.Second)
|
||||||
|
deadline := time.Now().Add(timeout)
|
||||||
|
d := net.Dialer{Deadline: deadline}
|
||||||
|
conn, err := d.DialContext(ctx, "tcp", c.Addr.String())
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
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)
|
||||||
|
c.Registry.Each(func(name string, i any) {
|
||||||
|
switch metric := i.(type) {
|
||||||
|
case metrics.Counter:
|
||||||
|
count := metric.Count()
|
||||||
|
fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, count, now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.count_ps %.2f %d\n", c.Prefix, name, float64(count)/flushSeconds, now)
|
||||||
|
case metrics.Gauge:
|
||||||
|
fmt.Fprintf(w, "%s.%s.value %d %d\n", c.Prefix, name, metric.Value(), now)
|
||||||
|
case metrics.GaugeFloat64:
|
||||||
|
fmt.Fprintf(w, "%s.%s.value %f %d\n", c.Prefix, name, metric.Value(), now)
|
||||||
|
case metrics.Histogram:
|
||||||
|
h := metric.Snapshot()
|
||||||
|
ps := h.Percentiles(c.Percentiles)
|
||||||
|
fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, h.Count(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.min %d %d\n", c.Prefix, name, h.Min(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.max %d %d\n", c.Prefix, name, h.Max(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", c.Prefix, name, h.Mean(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", c.Prefix, name, h.StdDev(), now)
|
||||||
|
for psIdx, psKey := range c.Percentiles {
|
||||||
|
key := strings.Replace(strconv.FormatFloat(psKey*100.0, 'f', -1, 64), ".", "", 1)
|
||||||
|
fmt.Fprintf(w, "%s.%s.%s-percentile %.2f %d\n", c.Prefix, name, key, ps[psIdx], now)
|
||||||
|
}
|
||||||
|
case metrics.Meter:
|
||||||
|
m := metric.Snapshot()
|
||||||
|
fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, m.Count(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.one-minute %.2f %d\n", c.Prefix, name, m.Rate1(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.five-minute %.2f %d\n", c.Prefix, name, m.Rate5(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", c.Prefix, name, m.Rate15(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", c.Prefix, name, m.RateMean(), now)
|
||||||
|
case metrics.Timer:
|
||||||
|
t := metric.Snapshot()
|
||||||
|
ps := t.Percentiles(c.Percentiles)
|
||||||
|
count := t.Count()
|
||||||
|
fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, count, now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.count_ps %.2f %d\n", c.Prefix, name, float64(count)/flushSeconds, now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.min %d %d\n", c.Prefix, name, t.Min()/int64(du), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.max %d %d\n", c.Prefix, name, t.Max()/int64(du), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", c.Prefix, name, t.Mean()/du, now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", c.Prefix, name, t.StdDev()/du, now)
|
||||||
|
for psIdx, psKey := range c.Percentiles {
|
||||||
|
key := strings.Replace(strconv.FormatFloat(psKey*100.0, 'f', -1, 64), ".", "", 1)
|
||||||
|
fmt.Fprintf(w, "%s.%s.%s-percentile %.2f %d\n", c.Prefix, name, key, ps[psIdx]/du, now)
|
||||||
|
}
|
||||||
|
fmt.Fprintf(w, "%s.%s.one-minute %.2f %d\n", c.Prefix, name, t.Rate1(), now)
|
||||||
|
fmt.Fprintf(w, "%s.%s.five-minute %.2f %d\n", c.Prefix, name, t.Rate5(), 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)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
// A failed write sticks, so this reports the first one
|
||||||
|
return w.Flush()
|
||||||
|
}
|
||||||
@@ -0,0 +1,315 @@
|
|||||||
|
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")
|
||||||
|
}
|
||||||
@@ -35,7 +35,9 @@ func NewCredential(
|
|||||||
}
|
}
|
||||||
|
|
||||||
// buildHandshakeState creates a noise.HandshakeState from this credential.
|
// buildHandshakeState creates a noise.HandshakeState from this credential.
|
||||||
func (hc *Credential) buildHandshakeState(initiator bool, pattern noise.HandshakePattern) (*noise.HandshakeState, error) {
|
// pskPlacement selects the noise psk modifier; 0 means none. A psk for
|
||||||
|
// placements 2 and up is supplied later with SetPresharedKey.
|
||||||
|
func (hc *Credential) buildHandshakeState(initiator bool, pattern noise.HandshakePattern, pskPlacement int) (*noise.HandshakeState, error) {
|
||||||
return noise.NewHandshakeState(noise.Config{
|
return noise.NewHandshakeState(noise.Config{
|
||||||
CipherSuite: hc.cipherSuite,
|
CipherSuite: hc.cipherSuite,
|
||||||
Random: rand.Reader,
|
Random: rand.Reader,
|
||||||
@@ -43,7 +45,7 @@ func (hc *Credential) buildHandshakeState(initiator bool, pattern noise.Handshak
|
|||||||
Initiator: initiator,
|
Initiator: initiator,
|
||||||
StaticKeypair: noise.DHKey{Private: hc.privateKey, Public: hc.Cert.PublicKey()},
|
StaticKeypair: noise.DHKey{Private: hc.privateKey, Public: hc.Cert.PublicKey()},
|
||||||
PresharedKey: []byte{},
|
PresharedKey: []byte{},
|
||||||
PresharedKeyPlacement: 0,
|
PresharedKeyPlacement: pskPlacement,
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,216 @@
|
|||||||
|
// Package fec implements the systematic Reed-Solomon erasure code used to carry
|
||||||
|
// handshake messages that do not fit in a single UDP packet.
|
||||||
|
//
|
||||||
|
// A message is split into K equally sized data symbols (the last one zero
|
||||||
|
// padded). Symbol indexes 0..K-1 are the data symbols themselves; indexes
|
||||||
|
// K..MaxSymbols-1 are repair symbols. Any K distinct symbols reconstruct the
|
||||||
|
// message. Repair symbols are generated on demand, so a sender can emit fresh
|
||||||
|
// ones on every retransmit and a receiver can merge everything it has seen.
|
||||||
|
package fec
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
)
|
||||||
|
|
||||||
|
// MaxSymbols is the number of distinct symbols, data and repair together, one
|
||||||
|
// message can be encoded into. It is bounded by the size of GF(2^8).
|
||||||
|
const MaxSymbols = 256
|
||||||
|
|
||||||
|
var (
|
||||||
|
ErrInvalidLayout = errors.New("invalid fec layout")
|
||||||
|
ErrIndexRange = errors.New("symbol index out of range")
|
||||||
|
ErrSymbolSize = errors.New("symbol has the wrong size")
|
||||||
|
ErrNotEnough = errors.New("not enough symbols to decode")
|
||||||
|
ErrCorrupt = errors.New("decoded message has non-zero padding")
|
||||||
|
)
|
||||||
|
|
||||||
|
// Layout describes how a message is split into symbols. Both ends derive it
|
||||||
|
// from the message length alone, so it never has to be sent.
|
||||||
|
type Layout struct {
|
||||||
|
MsgLen int // length of the message in bytes
|
||||||
|
K int // number of data symbols
|
||||||
|
SymbolSize int // size of every symbol, data and repair
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewLayout returns the layout for a message of msgLen bytes carried in symbols
|
||||||
|
// of at most maxSymbolSize bytes. Symbols are balanced, so padding is always
|
||||||
|
// less than K bytes.
|
||||||
|
func NewLayout(msgLen, maxSymbolSize int) (Layout, error) {
|
||||||
|
if msgLen <= 0 || maxSymbolSize <= 0 {
|
||||||
|
return Layout{}, ErrInvalidLayout
|
||||||
|
}
|
||||||
|
k := (msgLen + maxSymbolSize - 1) / maxSymbolSize
|
||||||
|
if k >= MaxSymbols {
|
||||||
|
return Layout{}, fmt.Errorf("%w: %d data symbols", ErrInvalidLayout, k)
|
||||||
|
}
|
||||||
|
return Layout{
|
||||||
|
MsgLen: msgLen,
|
||||||
|
K: k,
|
||||||
|
SymbolSize: (msgLen + k - 1) / k,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Encoder produces symbols for one message.
|
||||||
|
type Encoder struct {
|
||||||
|
layout Layout
|
||||||
|
data [][]byte
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewEncoder copies msg into padded data symbols.
|
||||||
|
func NewEncoder(msg []byte, maxSymbolSize int) (*Encoder, error) {
|
||||||
|
l, err := NewLayout(len(msg), maxSymbolSize)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
buf := make([]byte, l.K*l.SymbolSize)
|
||||||
|
copy(buf, msg)
|
||||||
|
data := make([][]byte, l.K)
|
||||||
|
for i := range data {
|
||||||
|
data[i] = buf[i*l.SymbolSize : (i+1)*l.SymbolSize]
|
||||||
|
}
|
||||||
|
return &Encoder{layout: l, data: data}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (e *Encoder) Layout() Layout {
|
||||||
|
return e.layout
|
||||||
|
}
|
||||||
|
|
||||||
|
// Symbol appends the symbol with the given index to dst and returns the result.
|
||||||
|
func (e *Encoder) Symbol(dst []byte, index int) ([]byte, error) {
|
||||||
|
if index < 0 || index >= MaxSymbols {
|
||||||
|
return nil, ErrIndexRange
|
||||||
|
}
|
||||||
|
if index < e.layout.K {
|
||||||
|
return append(dst, e.data[index]...), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
start := len(dst)
|
||||||
|
dst = append(dst, make([]byte, e.layout.SymbolSize)...)
|
||||||
|
out := dst[start:]
|
||||||
|
for col, d := range e.data {
|
||||||
|
mulAdd(out, d, coefficient(index, col))
|
||||||
|
}
|
||||||
|
return dst, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decoder collects symbols for one message until it can reconstruct it.
|
||||||
|
// It stores at most K symbols, so its memory is bounded by the layout no matter
|
||||||
|
// how many symbols arrive.
|
||||||
|
type Decoder struct {
|
||||||
|
layout Layout
|
||||||
|
have [MaxSymbols]bool
|
||||||
|
syms map[int][]byte
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewDecoder returns a decoder for a message of msgLen bytes that was encoded
|
||||||
|
// with the same maxSymbolSize.
|
||||||
|
func NewDecoder(msgLen, maxSymbolSize int) (*Decoder, error) {
|
||||||
|
l, err := NewLayout(msgLen, maxSymbolSize)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return &Decoder{layout: l, syms: make(map[int][]byte, l.K)}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Decoder) Layout() Layout {
|
||||||
|
return d.layout
|
||||||
|
}
|
||||||
|
|
||||||
|
// Stored returns the number of symbols held.
|
||||||
|
func (d *Decoder) Stored() int {
|
||||||
|
return len(d.syms)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Has reports whether the symbol with the given index is held.
|
||||||
|
func (d *Decoder) Has(index int) bool {
|
||||||
|
return index >= 0 && index < MaxSymbols && d.have[index]
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ready reports whether enough symbols have arrived to decode.
|
||||||
|
func (d *Decoder) Ready() bool {
|
||||||
|
return len(d.syms) >= d.layout.K
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add stores a copy of the symbol. Duplicates, and anything beyond the first K
|
||||||
|
// distinct symbols, are ignored. It returns whether the decoder is ready.
|
||||||
|
func (d *Decoder) Add(index int, sym []byte) (bool, error) {
|
||||||
|
if index < 0 || index >= MaxSymbols {
|
||||||
|
return d.Ready(), ErrIndexRange
|
||||||
|
}
|
||||||
|
if len(sym) != d.layout.SymbolSize {
|
||||||
|
return d.Ready(), ErrSymbolSize
|
||||||
|
}
|
||||||
|
if d.have[index] || d.Ready() {
|
||||||
|
return d.Ready(), nil
|
||||||
|
}
|
||||||
|
d.have[index] = true
|
||||||
|
d.syms[index] = append([]byte(nil), sym...)
|
||||||
|
return d.Ready(), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decode reconstructs the message from the stored symbols.
|
||||||
|
func (d *Decoder) Decode() ([]byte, error) {
|
||||||
|
if !d.Ready() {
|
||||||
|
return nil, ErrNotEnough
|
||||||
|
}
|
||||||
|
l := d.layout
|
||||||
|
|
||||||
|
out := make([]byte, l.K*l.SymbolSize)
|
||||||
|
var missing, repair []int
|
||||||
|
for i := range l.K {
|
||||||
|
if s, ok := d.syms[i]; ok {
|
||||||
|
copy(out[i*l.SymbolSize:], s)
|
||||||
|
} else {
|
||||||
|
missing = append(missing, i)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if len(missing) > 0 {
|
||||||
|
for i := l.K; i < MaxSymbols && len(repair) < len(missing); i++ {
|
||||||
|
if d.have[i] {
|
||||||
|
repair = append(repair, i)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if len(repair) < len(missing) {
|
||||||
|
return nil, ErrNotEnough
|
||||||
|
}
|
||||||
|
|
||||||
|
// Each repair symbol r satisfies r = sum_col coefficient(r, col) * data[col].
|
||||||
|
// Move the known data columns to the left hand side, leaving a square
|
||||||
|
// Cauchy system in the missing columns.
|
||||||
|
rhs := make([][]byte, len(repair))
|
||||||
|
m := make([][]byte, len(repair))
|
||||||
|
for ri, row := range repair {
|
||||||
|
rhs[ri] = append([]byte(nil), d.syms[row]...)
|
||||||
|
m[ri] = make([]byte, len(missing))
|
||||||
|
mi := 0
|
||||||
|
for col := range l.K {
|
||||||
|
if mi < len(missing) && missing[mi] == col {
|
||||||
|
m[ri][mi] = coefficient(row, col)
|
||||||
|
mi++
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
mulAdd(rhs[ri], out[col*l.SymbolSize:(col+1)*l.SymbolSize], coefficient(row, col))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !invert(m) {
|
||||||
|
// Unreachable for a Cauchy matrix; kept so a broken invariant fails loudly.
|
||||||
|
return nil, errors.New("fec: singular decode matrix")
|
||||||
|
}
|
||||||
|
for mi, col := range missing {
|
||||||
|
dst := out[col*l.SymbolSize : (col+1)*l.SymbolSize]
|
||||||
|
for ri := range repair {
|
||||||
|
mulAdd(dst, rhs[ri], m[mi][ri])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, b := range out[l.MsgLen:] {
|
||||||
|
if b != 0 {
|
||||||
|
return nil, ErrCorrupt
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return out[:l.MsgLen], nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,318 @@
|
|||||||
|
package fec
|
||||||
|
|
||||||
|
import (
|
||||||
|
"crypto/sha256"
|
||||||
|
"encoding/hex"
|
||||||
|
"math/rand/v2"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
)
|
||||||
|
|
||||||
|
// slowMul is carry-less multiplication reduced by gfPoly, used to check the tables.
|
||||||
|
func slowMul(a, b byte) byte {
|
||||||
|
var p int
|
||||||
|
x, y := int(a), int(b)
|
||||||
|
for y > 0 {
|
||||||
|
if y&1 != 0 {
|
||||||
|
p ^= x
|
||||||
|
}
|
||||||
|
x <<= 1
|
||||||
|
if x&0x100 != 0 {
|
||||||
|
x ^= gfPoly
|
||||||
|
}
|
||||||
|
y >>= 1
|
||||||
|
}
|
||||||
|
return byte(p)
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestGF(t *testing.T) {
|
||||||
|
for a := range 256 {
|
||||||
|
for b := range 256 {
|
||||||
|
require.Equal(t, slowMul(byte(a), byte(b)), gfMul(byte(a), byte(b)), "%d*%d", a, b)
|
||||||
|
}
|
||||||
|
if a != 0 {
|
||||||
|
require.Equal(t, byte(1), gfMul(byte(a), gfInv(byte(a))), "inv(%d)", a)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
src := make([]byte, 256)
|
||||||
|
for i := range src {
|
||||||
|
src[i] = byte(i)
|
||||||
|
}
|
||||||
|
for c := range 256 {
|
||||||
|
dst := make([]byte, 256)
|
||||||
|
mulAdd(dst, src, byte(c))
|
||||||
|
for i := range src {
|
||||||
|
require.Equal(t, gfMul(byte(c), src[i]), dst[i])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLayout(t *testing.T) {
|
||||||
|
for msgLen := 1; msgLen <= 20000; msgLen++ {
|
||||||
|
l, err := NewLayout(msgLen, 1176)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Equal(t, (msgLen+1175)/1176, l.K)
|
||||||
|
require.LessOrEqual(t, l.SymbolSize, 1176)
|
||||||
|
require.GreaterOrEqual(t, l.K*l.SymbolSize, msgLen)
|
||||||
|
require.Less(t, l.K*l.SymbolSize-msgLen, l.K, "padding must be less than one byte per symbol")
|
||||||
|
}
|
||||||
|
|
||||||
|
l, err := NewLayout(65535, 1176)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, 56, l.K)
|
||||||
|
|
||||||
|
_, err = NewLayout(0, 1176)
|
||||||
|
require.ErrorIs(t, err, ErrInvalidLayout)
|
||||||
|
_, err = NewLayout(100, 0)
|
||||||
|
require.ErrorIs(t, err, ErrInvalidLayout)
|
||||||
|
_, err = NewLayout(256, 1)
|
||||||
|
require.ErrorIs(t, err, ErrInvalidLayout)
|
||||||
|
_, err = NewLayout(255, 1)
|
||||||
|
require.NoError(t, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
func randMsg(r *rand.Rand, n int) []byte {
|
||||||
|
b := make([]byte, n)
|
||||||
|
for i := range b {
|
||||||
|
b[i] = byte(r.Uint32())
|
||||||
|
}
|
||||||
|
return b
|
||||||
|
}
|
||||||
|
|
||||||
|
func decodeWith(t *testing.T, enc *Encoder, msgLen, maxSym int, indexes []int) []byte {
|
||||||
|
t.Helper()
|
||||||
|
dec, err := NewDecoder(msgLen, maxSym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
for _, idx := range indexes {
|
||||||
|
sym, err := enc.Symbol(nil, idx)
|
||||||
|
require.NoError(t, err)
|
||||||
|
_, err = dec.Add(idx, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
}
|
||||||
|
require.True(t, dec.Ready())
|
||||||
|
out, err := dec.Decode()
|
||||||
|
require.NoError(t, err)
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestExhaustiveSubsets decodes every k-subset of the first k+m symbols for
|
||||||
|
// small codes, which checks the MDS property directly.
|
||||||
|
func TestExhaustiveSubsets(t *testing.T) {
|
||||||
|
r := rand.New(rand.NewPCG(1, 2))
|
||||||
|
const maxSym = 16
|
||||||
|
for k := 1; k <= 10; k++ {
|
||||||
|
for m := 1; m <= 5; m++ {
|
||||||
|
msgLen := (k-1)*maxSym + 1 + r.IntN(maxSym)
|
||||||
|
msg := randMsg(r, msgLen)
|
||||||
|
enc, err := NewEncoder(msg, maxSym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Equal(t, k, enc.Layout().K)
|
||||||
|
|
||||||
|
n := k + m
|
||||||
|
for mask := 0; mask < 1<<n; mask++ {
|
||||||
|
var idx []int
|
||||||
|
for i := range n {
|
||||||
|
if mask&(1<<i) != 0 {
|
||||||
|
idx = append(idx, i)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if len(idx) != k {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
require.Equal(t, msg, decodeWith(t, enc, msgLen, maxSym, idx), "k=%d m=%d idx=%v", k, m, idx)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestRandomHighIndexes draws symbols from the whole index space, the shape
|
||||||
|
// retransmits produce once fresh repair symbols are in play.
|
||||||
|
func TestRandomHighIndexes(t *testing.T) {
|
||||||
|
r := rand.New(rand.NewPCG(3, 4))
|
||||||
|
for range 2000 {
|
||||||
|
msgLen := 1 + r.IntN(65535)
|
||||||
|
msg := randMsg(r, msgLen)
|
||||||
|
enc, err := NewEncoder(msg, 1176)
|
||||||
|
require.NoError(t, err)
|
||||||
|
k := enc.Layout().K
|
||||||
|
|
||||||
|
idx := r.Perm(MaxSymbols)[:k]
|
||||||
|
require.Equal(t, msg, decodeWith(t, enc, msgLen, 1176, idx), "k=%d idx=%v", k, idx)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestDecoderBounds(t *testing.T) {
|
||||||
|
r := rand.New(rand.NewPCG(5, 6))
|
||||||
|
msg := randMsg(r, 3000)
|
||||||
|
enc, err := NewEncoder(msg, 1176)
|
||||||
|
require.NoError(t, err)
|
||||||
|
l := enc.Layout()
|
||||||
|
require.Equal(t, 3, l.K)
|
||||||
|
require.Equal(t, 1000, l.SymbolSize)
|
||||||
|
|
||||||
|
dec, err := NewDecoder(3000, 1176)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
_, err = dec.Decode()
|
||||||
|
require.ErrorIs(t, err, ErrNotEnough)
|
||||||
|
|
||||||
|
_, err = dec.Add(-1, make([]byte, 1000))
|
||||||
|
require.ErrorIs(t, err, ErrIndexRange)
|
||||||
|
_, err = dec.Add(MaxSymbols, make([]byte, 1000))
|
||||||
|
require.ErrorIs(t, err, ErrIndexRange)
|
||||||
|
_, err = dec.Add(0, make([]byte, 999))
|
||||||
|
require.ErrorIs(t, err, ErrSymbolSize)
|
||||||
|
|
||||||
|
s5, _ := enc.Symbol(nil, 5)
|
||||||
|
ready, err := dec.Add(5, s5)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.False(t, ready)
|
||||||
|
|
||||||
|
// A duplicate index is ignored, even with different contents.
|
||||||
|
ready, err = dec.Add(5, make([]byte, 1000))
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.False(t, ready)
|
||||||
|
|
||||||
|
s0, _ := enc.Symbol(nil, 0)
|
||||||
|
s9, _ := enc.Symbol(nil, 9)
|
||||||
|
_, err = dec.Add(0, s0)
|
||||||
|
require.NoError(t, err)
|
||||||
|
ready, err = dec.Add(9, s9)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.True(t, ready)
|
||||||
|
|
||||||
|
// Symbols beyond K are not stored.
|
||||||
|
ready, err = dec.Add(1, make([]byte, 1000))
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.True(t, ready)
|
||||||
|
require.Len(t, dec.syms, 3)
|
||||||
|
|
||||||
|
out, err := dec.Decode()
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Equal(t, msg, out)
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestCorruptPadding(t *testing.T) {
|
||||||
|
// 3001 bytes in 3 symbols of 1001 leaves 2 bytes of padding in the last one.
|
||||||
|
dec, err := NewDecoder(3001, 1176)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Equal(t, 1001, dec.Layout().SymbolSize)
|
||||||
|
|
||||||
|
last := make([]byte, 1001)
|
||||||
|
last[1000] = 1
|
||||||
|
for i, s := range [][]byte{make([]byte, 1001), make([]byte, 1001), last} {
|
||||||
|
_, err = dec.Add(i, s)
|
||||||
|
require.NoError(t, err)
|
||||||
|
}
|
||||||
|
_, err = dec.Decode()
|
||||||
|
require.ErrorIs(t, err, ErrCorrupt)
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestKnownAnswer pins the encoding. Both ends of a handshake must produce
|
||||||
|
// identical repair symbols, so any change here is a wire format change.
|
||||||
|
func TestKnownAnswer(t *testing.T) {
|
||||||
|
msg := make([]byte, 3000)
|
||||||
|
for i := range msg {
|
||||||
|
msg[i] = byte(i*7 + 3)
|
||||||
|
}
|
||||||
|
enc, err := NewEncoder(msg, 1176)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
// Cross-checked against an independent bit-serial GF(2^8) implementation.
|
||||||
|
want := map[int]string{
|
||||||
|
3: "52124f58276ec6338d3b3f4eed273bc7cabfe4f0f467928962b046ad1b348f50",
|
||||||
|
4: "a50928b04738981985a7d4a17ffaf8d7e30014ca64fc53c99800ffb61aec4aa7",
|
||||||
|
5: "ada4c95a7facbc542aaef584e6f0d081b7b0d0eed69ded03b57d0753a119cfc9",
|
||||||
|
255: "839066cdf94f963b223fb1c1c1360f698c14f6349b25653ff5b521791a4021b1",
|
||||||
|
}
|
||||||
|
for idx, h := range want {
|
||||||
|
sym, err := enc.Symbol(nil, idx)
|
||||||
|
require.NoError(t, err)
|
||||||
|
sum := sha256.Sum256(sym)
|
||||||
|
assert.Equal(t, h, hex.EncodeToString(sum[:]), "symbol %d", idx)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func FuzzRoundTrip(f *testing.F) {
|
||||||
|
f.Add([]byte("hello"), uint16(2), uint64(0))
|
||||||
|
f.Add(make([]byte, 9000), uint16(1176), uint64(7))
|
||||||
|
f.Fuzz(func(t *testing.T, msg []byte, maxSym uint16, seed uint64) {
|
||||||
|
if len(msg) == 0 || maxSym == 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
enc, err := NewEncoder(msg, int(maxSym))
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
r := rand.New(rand.NewPCG(seed, seed))
|
||||||
|
idx := r.Perm(MaxSymbols)[:enc.Layout().K]
|
||||||
|
require.Equal(t, msg, decodeWith(t, enc, len(msg), int(maxSym), idx))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// FuzzDecoder feeds arbitrary symbols to a decoder; it must never panic and
|
||||||
|
// must either fail or return a message of the declared length.
|
||||||
|
func FuzzDecoder(f *testing.F) {
|
||||||
|
f.Add(uint16(3000), []byte{0, 5, 9, 200}, []byte("some symbol bytes"))
|
||||||
|
f.Fuzz(func(t *testing.T, msgLen uint16, indexes []byte, fill []byte) {
|
||||||
|
dec, err := NewDecoder(int(msgLen), 1176)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
size := dec.Layout().SymbolSize
|
||||||
|
for i, idx := range indexes {
|
||||||
|
sym := make([]byte, size)
|
||||||
|
for j := range sym {
|
||||||
|
if len(fill) > 0 {
|
||||||
|
sym[j] = fill[(i+j)%len(fill)]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if _, err := dec.Add(int(idx), sym); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out, err := dec.Decode()
|
||||||
|
if err == nil {
|
||||||
|
require.Len(t, out, int(msgLen))
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// BenchmarkRepair and BenchmarkDecode use a v3-sized msg2 (~9.8KB, k=9) with
|
||||||
|
// three repair symbols, decoding with three data symbols missing.
|
||||||
|
func BenchmarkRepair(b *testing.B) {
|
||||||
|
msg := randMsg(rand.New(rand.NewPCG(7, 8)), 9800)
|
||||||
|
enc, err := NewEncoder(msg, 1176)
|
||||||
|
require.NoError(b, err)
|
||||||
|
buf := make([]byte, 0, 1176)
|
||||||
|
b.SetBytes(int64(len(msg)))
|
||||||
|
for b.Loop() {
|
||||||
|
for idx := 9; idx < 12; idx++ {
|
||||||
|
buf, _ = enc.Symbol(buf[:0], idx)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func BenchmarkDecode(b *testing.B) {
|
||||||
|
msg := randMsg(rand.New(rand.NewPCG(7, 8)), 9800)
|
||||||
|
enc, err := NewEncoder(msg, 1176)
|
||||||
|
require.NoError(b, err)
|
||||||
|
idx := []int{0, 1, 2, 3, 5, 6, 9, 10, 11}
|
||||||
|
syms := make([][]byte, len(idx))
|
||||||
|
for i, x := range idx {
|
||||||
|
syms[i], _ = enc.Symbol(nil, x)
|
||||||
|
}
|
||||||
|
b.SetBytes(int64(len(msg)))
|
||||||
|
for b.Loop() {
|
||||||
|
dec, _ := NewDecoder(len(msg), 1176)
|
||||||
|
for i, x := range idx {
|
||||||
|
_, _ = dec.Add(x, syms[i])
|
||||||
|
}
|
||||||
|
if _, err := dec.Decode(); err != nil {
|
||||||
|
b.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,115 @@
|
|||||||
|
package fec
|
||||||
|
|
||||||
|
// Arithmetic over GF(2^8) with the reducing polynomial x^8+x^4+x^3+x^2+1 (0x11d).
|
||||||
|
// Addition is XOR. Multiplication uses log/exp tables; the exp table is doubled so
|
||||||
|
// the sum of two logs never needs reducing mod 255.
|
||||||
|
|
||||||
|
const gfPoly = 0x11d
|
||||||
|
|
||||||
|
var (
|
||||||
|
gfExp [510]byte
|
||||||
|
gfLog [256]byte
|
||||||
|
)
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
x := 1
|
||||||
|
for i := range 255 {
|
||||||
|
gfExp[i] = byte(x)
|
||||||
|
gfExp[i+255] = byte(x)
|
||||||
|
gfLog[x] = byte(i)
|
||||||
|
x <<= 1
|
||||||
|
if x&0x100 != 0 {
|
||||||
|
x ^= gfPoly
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func gfMul(a, b byte) byte {
|
||||||
|
if a == 0 || b == 0 {
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
return gfExp[int(gfLog[a])+int(gfLog[b])]
|
||||||
|
}
|
||||||
|
|
||||||
|
// gfInv returns the multiplicative inverse of a. a must be non-zero.
|
||||||
|
func gfInv(a byte) byte {
|
||||||
|
return gfExp[255-int(gfLog[a])]
|
||||||
|
}
|
||||||
|
|
||||||
|
// mulAdd computes dst ^= c*src element-wise. dst must be at least as long as src.
|
||||||
|
func mulAdd(dst, src []byte, c byte) {
|
||||||
|
switch c {
|
||||||
|
case 0:
|
||||||
|
return
|
||||||
|
case 1:
|
||||||
|
for i, s := range src {
|
||||||
|
dst[i] ^= s
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
var t [256]byte
|
||||||
|
lc := int(gfLog[c])
|
||||||
|
for s := 1; s < 256; s++ {
|
||||||
|
t[s] = gfExp[int(gfLog[s])+lc]
|
||||||
|
}
|
||||||
|
for i, s := range src {
|
||||||
|
dst[i] ^= t[s]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// coefficient returns the generator matrix entry for repair symbol index row and
|
||||||
|
// data symbol index col. Repair rows are a Cauchy matrix 1/(x_row + y_col) with
|
||||||
|
// x_row = row and y_col = col: rows are always >= k and columns < k so the two
|
||||||
|
// sets are disjoint, which makes every square submatrix invertible and the
|
||||||
|
// systematic code [I; C] MDS. A row depends only on its index, never on how many
|
||||||
|
// repair symbols exist, so new repair symbols can be generated at any time.
|
||||||
|
func coefficient(row, col int) byte {
|
||||||
|
return gfInv(byte(row) ^ byte(col))
|
||||||
|
}
|
||||||
|
|
||||||
|
// invert inverts the n x n matrix m in place with Gauss-Jordan elimination.
|
||||||
|
// It returns false if m is singular.
|
||||||
|
func invert(m [][]byte) bool {
|
||||||
|
n := len(m)
|
||||||
|
inv := make([][]byte, n)
|
||||||
|
for i := range inv {
|
||||||
|
inv[i] = make([]byte, n)
|
||||||
|
inv[i][i] = 1
|
||||||
|
}
|
||||||
|
|
||||||
|
for col := range n {
|
||||||
|
pivot := -1
|
||||||
|
for r := col; r < n; r++ {
|
||||||
|
if m[r][col] != 0 {
|
||||||
|
pivot = r
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if pivot < 0 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
m[col], m[pivot] = m[pivot], m[col]
|
||||||
|
inv[col], inv[pivot] = inv[pivot], inv[col]
|
||||||
|
|
||||||
|
scale := gfInv(m[col][col])
|
||||||
|
for c := range n {
|
||||||
|
m[col][c] = gfMul(m[col][c], scale)
|
||||||
|
inv[col][c] = gfMul(inv[col][c], scale)
|
||||||
|
}
|
||||||
|
|
||||||
|
for r := 0; r < n; r++ {
|
||||||
|
if r == col || m[r][col] == 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
f := m[r][col]
|
||||||
|
for c := range n {
|
||||||
|
m[r][c] ^= gfMul(f, m[col][c])
|
||||||
|
inv[r][c] ^= gfMul(f, inv[col][c])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
copy(m, inv)
|
||||||
|
return true
|
||||||
|
}
|
||||||
@@ -0,0 +1,67 @@
|
|||||||
|
package fragment
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/handshake/fec"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
)
|
||||||
|
|
||||||
|
// ErrMismatch is returned when a fragment disagrees with the message it claims to
|
||||||
|
// belong to. The caller should discard the whole assembly.
|
||||||
|
var ErrMismatch = errors.New("fragment does not match its message")
|
||||||
|
|
||||||
|
// Assembly collects the fragments of one incoming message. Its memory is bounded
|
||||||
|
// by the message length: at most K symbols are kept however many arrive.
|
||||||
|
//
|
||||||
|
// An Assembly is not safe for concurrent use.
|
||||||
|
type Assembly struct {
|
||||||
|
fragID uint32
|
||||||
|
msgLen uint16
|
||||||
|
dec *fec.Decoder
|
||||||
|
received int
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewAssembly starts an assembly for the message described by h. The fragment
|
||||||
|
// itself still has to be passed to Add.
|
||||||
|
func NewAssembly(h Header) (*Assembly, error) {
|
||||||
|
dec, err := fec.NewDecoder(int(h.MsgLen), MaxSymbolSize)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return &Assembly{fragID: h.FragID, msgLen: h.MsgLen, dec: dec}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add records a fragment parsed by Parse. It returns true once enough symbols
|
||||||
|
// are held to call Decode.
|
||||||
|
func (a *Assembly) Add(h Header, sym []byte) (bool, error) {
|
||||||
|
if h.FragID != a.fragID || h.MsgLen != a.msgLen {
|
||||||
|
return a.dec.Ready(), ErrMismatch
|
||||||
|
}
|
||||||
|
a.received += header.Len + HeaderLen + len(sym)
|
||||||
|
return a.dec.Add(int(h.Index), sym)
|
||||||
|
}
|
||||||
|
|
||||||
|
// wouldStore returns how many bytes Add would retain for this fragment.
|
||||||
|
func (a *Assembly) wouldStore(h Header, sym []byte) int {
|
||||||
|
if h.FragID != a.fragID || h.MsgLen != a.msgLen || a.dec.Ready() || a.dec.Has(int(h.Index)) {
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
return len(sym)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decode reconstructs the message. It requires Add to have reported ready.
|
||||||
|
func (a *Assembly) Decode() ([]byte, error) {
|
||||||
|
return a.dec.Decode()
|
||||||
|
}
|
||||||
|
|
||||||
|
// Stored returns the number of symbol bytes held.
|
||||||
|
func (a *Assembly) Stored() int {
|
||||||
|
return a.dec.Stored() * a.dec.Layout().SymbolSize
|
||||||
|
}
|
||||||
|
|
||||||
|
// Received returns the number of packet bytes received for this message,
|
||||||
|
// duplicates included. It is the basis for the amplification budget.
|
||||||
|
func (a *Assembly) Received() int {
|
||||||
|
return a.received
|
||||||
|
}
|
||||||
@@ -0,0 +1,515 @@
|
|||||||
|
package fragment
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"math/rand/v2"
|
||||||
|
"sync"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
)
|
||||||
|
|
||||||
|
const testSubtype = header.MessageSubType(9)
|
||||||
|
|
||||||
|
type testKey struct {
|
||||||
|
src string
|
||||||
|
fragID uint32
|
||||||
|
}
|
||||||
|
|
||||||
|
func randMsg(r *rand.Rand, n int) []byte {
|
||||||
|
b := make([]byte, n)
|
||||||
|
for i := range b {
|
||||||
|
b[i] = byte(r.Uint32())
|
||||||
|
}
|
||||||
|
return b
|
||||||
|
}
|
||||||
|
|
||||||
|
func testConfig() TableConfig {
|
||||||
|
return TableConfig{
|
||||||
|
MaxBytes: 1 << 20,
|
||||||
|
MaxEntries: 64,
|
||||||
|
MaxPerSource: 4,
|
||||||
|
MaxMsgLen: 16384,
|
||||||
|
TTL: 2 * time.Second,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// checkInvariants verifies the table's bookkeeping against its contents.
|
||||||
|
func checkInvariants[K, S comparable](t *testing.T, tb *Table[K, S]) {
|
||||||
|
t.Helper()
|
||||||
|
tb.mu.Lock()
|
||||||
|
defer tb.mu.Unlock()
|
||||||
|
|
||||||
|
require.Len(t, tb.order, len(tb.entries))
|
||||||
|
require.LessOrEqual(t, len(tb.entries), tb.cfg.MaxEntries)
|
||||||
|
bytes := 0
|
||||||
|
perSource := map[S]int{}
|
||||||
|
for i, key := range tb.order {
|
||||||
|
e, ok := tb.entries[key]
|
||||||
|
require.True(t, ok)
|
||||||
|
require.Equal(t, i, e.pos)
|
||||||
|
bytes += e.a.Stored()
|
||||||
|
perSource[e.source]++
|
||||||
|
}
|
||||||
|
require.Equal(t, bytes, tb.bytes)
|
||||||
|
require.LessOrEqual(t, tb.bytes, tb.cfg.MaxBytes)
|
||||||
|
require.Equal(t, perSource, tb.perSource)
|
||||||
|
for _, n := range perSource {
|
||||||
|
require.LessOrEqual(t, n, tb.cfg.MaxPerSource)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func parse(t *testing.T, p []byte) (header.H, Header, []byte) {
|
||||||
|
t.Helper()
|
||||||
|
var nh header.H
|
||||||
|
require.NoError(t, nh.Parse(p))
|
||||||
|
h, sym, err := Parse(p[header.Len:])
|
||||||
|
require.NoError(t, err)
|
||||||
|
return nh, h, sym
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestParse(t *testing.T) {
|
||||||
|
h := Header{FragID: 0xdeadbeef, MsgLen: 3000, Index: 7}
|
||||||
|
b := h.Encode(nil)
|
||||||
|
require.Len(t, b, HeaderLen)
|
||||||
|
b = append(b, make([]byte, 1000)...)
|
||||||
|
|
||||||
|
got, sym, err := Parse(b)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, h, got)
|
||||||
|
assert.Len(t, sym, 1000)
|
||||||
|
|
||||||
|
_, _, err = Parse(b[:HeaderLen-1])
|
||||||
|
require.ErrorIs(t, err, ErrShortFragment)
|
||||||
|
_, _, err = Parse(b[:len(b)-1])
|
||||||
|
require.ErrorIs(t, err, ErrSymbolSize)
|
||||||
|
_, _, err = Parse(append(b, 0))
|
||||||
|
require.ErrorIs(t, err, ErrSymbolSize)
|
||||||
|
|
||||||
|
bad := Header{FragID: 0, MsgLen: 3000}.Encode(nil)
|
||||||
|
_, _, err = Parse(append(bad, make([]byte, 1000)...))
|
||||||
|
require.ErrorIs(t, err, ErrFragID)
|
||||||
|
|
||||||
|
bad = Header{FragID: 1, MsgLen: 0}.Encode(nil)
|
||||||
|
_, _, err = Parse(bad)
|
||||||
|
require.ErrorIs(t, err, ErrMsgLen)
|
||||||
|
|
||||||
|
bad = Header{FragID: 1, MsgLen: 3000, Flags: 0x02}.Encode(nil)
|
||||||
|
_, _, err = Parse(append(bad, make([]byte, 1000)...))
|
||||||
|
require.ErrorIs(t, err, ErrFlags)
|
||||||
|
|
||||||
|
t.Run("cookie", func(t *testing.T) {
|
||||||
|
h := Header{FragID: 7, MsgLen: 3000, Index: 4, Flags: FlagCookie}
|
||||||
|
for i := range h.Cookie {
|
||||||
|
h.Cookie[i] = byte(i + 1)
|
||||||
|
}
|
||||||
|
b := h.Encode(nil)
|
||||||
|
require.Len(t, b, HeaderLen+CookieLen)
|
||||||
|
b = append(b, make([]byte, 1000)...)
|
||||||
|
|
||||||
|
got, sym, err := Parse(b)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, h, got)
|
||||||
|
assert.True(t, got.HasCookie())
|
||||||
|
assert.Len(t, sym, 1000)
|
||||||
|
|
||||||
|
_, _, err = Parse(b[:HeaderLen+CookieLen-1])
|
||||||
|
require.ErrorIs(t, err, ErrNoCookie)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestDefaultRepair(t *testing.T) {
|
||||||
|
for k, want := range map[int]int{1: 2, 2: 2, 6: 2, 7: 3, 9: 3, 10: 4, 14: 5} {
|
||||||
|
assert.Equal(t, want, DefaultRepair(k), "k=%d", k)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestSender(t *testing.T) {
|
||||||
|
_, err := NewSender(nil, testSubtype, 0, 1, 1)
|
||||||
|
require.ErrorIs(t, err, ErrMsgLen)
|
||||||
|
_, err = NewSender(make([]byte, 65536), testSubtype, 0, 1, 1)
|
||||||
|
require.ErrorIs(t, err, ErrMsgLen)
|
||||||
|
_, err = NewSender(make([]byte, 10), testSubtype, 0, 1, 0)
|
||||||
|
require.ErrorIs(t, err, ErrFragID)
|
||||||
|
|
||||||
|
msg := randMsg(rand.New(rand.NewPCG(1, 1)), 9800)
|
||||||
|
s, err := NewSender(msg, testSubtype, 77, 2, 1234)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Equal(t, 9, s.Layout().K)
|
||||||
|
|
||||||
|
indexes := func(ps [][]byte) []int {
|
||||||
|
var out []int
|
||||||
|
for _, p := range ps {
|
||||||
|
require.LessOrEqual(t, len(p), MaxPacketLen)
|
||||||
|
nh, h, _ := parse(t, p)
|
||||||
|
assert.Equal(t, header.Handshake, nh.Type)
|
||||||
|
assert.Equal(t, testSubtype, nh.Subtype)
|
||||||
|
assert.Equal(t, uint32(77), nh.RemoteIndex)
|
||||||
|
assert.Equal(t, uint64(2), nh.MessageCounter)
|
||||||
|
assert.Equal(t, uint32(1234), h.FragID)
|
||||||
|
assert.Equal(t, uint16(9800), h.MsgLen)
|
||||||
|
out = append(out, int(h.Index))
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
now, later, err := s.Attempt(3)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []int{0, 1, 2, 3, 4, 5, 6, 7, 8}, indexes(now))
|
||||||
|
assert.Equal(t, []int{9, 10, 11}, indexes(later))
|
||||||
|
|
||||||
|
// A retry offers only indexes the receiver has not seen.
|
||||||
|
now, later, err = s.Attempt(3)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []int{12, 13, 14, 15, 16, 17, 18, 19, 20}, indexes(now))
|
||||||
|
assert.Equal(t, []int{21, 22, 23}, indexes(later))
|
||||||
|
|
||||||
|
// A sender rebuilt from the same message resumes where it was told to.
|
||||||
|
s2, err := NewSender(msg, testSubtype, 77, 2, 1234)
|
||||||
|
require.NoError(t, err)
|
||||||
|
s2.SetNext(s.Next())
|
||||||
|
now2, _, err := s2.Attempt(0)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []int{24, 25, 26, 27, 28, 29, 30, 31, 32}, indexes(now2))
|
||||||
|
s2.SetNext(-1)
|
||||||
|
assert.Equal(t, 255, s2.Next())
|
||||||
|
|
||||||
|
// A cookie rides on every later packet, which still fits MaxPacketLen even
|
||||||
|
// with a full size symbol.
|
||||||
|
full, err := NewSender(make([]byte, 2*MaxSymbolSize), testSubtype, 0, 1, 9)
|
||||||
|
require.NoError(t, err)
|
||||||
|
full.SetCookie(Cookie{1, 2, 3})
|
||||||
|
pkts, _, err := full.Attempt(1)
|
||||||
|
require.NoError(t, err)
|
||||||
|
for _, p := range pkts {
|
||||||
|
assert.Len(t, p, MaxPacketLen)
|
||||||
|
_, h, _ := parse(t, p)
|
||||||
|
assert.True(t, h.HasCookie())
|
||||||
|
assert.Equal(t, Cookie{1, 2, 3}, h.Cookie)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Indexes wrap once the space is used up.
|
||||||
|
for range 19 {
|
||||||
|
_, _, err = s.Attempt(3)
|
||||||
|
require.NoError(t, err)
|
||||||
|
}
|
||||||
|
now, _, err = s.Attempt(3)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []int{252, 253, 254, 255, 0, 1, 2, 3, 4}, indexes(now))
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestLossy runs whole messages through heavy loss, reordering and duplication,
|
||||||
|
// merging across attempts, and checks the table ends empty.
|
||||||
|
func TestLossy(t *testing.T) {
|
||||||
|
r := rand.New(rand.NewPCG(2, 2))
|
||||||
|
tb := NewTable[testKey, string](testConfig())
|
||||||
|
now := time.Unix(1000, 0)
|
||||||
|
|
||||||
|
for i := range 300 {
|
||||||
|
msg := randMsg(r, 1+r.IntN(16384))
|
||||||
|
fragID := uint32(i + 1)
|
||||||
|
s, err := NewSender(msg, testSubtype, 0, 1, fragID)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
var got *Result
|
||||||
|
for attempt := 0; got == nil; attempt++ {
|
||||||
|
require.Less(t, attempt, 20, "message never completed")
|
||||||
|
a, b, err := s.Attempt(DefaultRepair(s.Layout().K))
|
||||||
|
require.NoError(t, err)
|
||||||
|
var pkts [][]byte
|
||||||
|
for _, p := range append(a, b...) {
|
||||||
|
if r.Float64() < 0.3 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
pkts = append(pkts, p)
|
||||||
|
if r.Float64() < 0.2 {
|
||||||
|
pkts = append(pkts, p)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
r.Shuffle(len(pkts), func(i, j int) { pkts[i], pkts[j] = pkts[j], pkts[i] })
|
||||||
|
|
||||||
|
for _, p := range pkts {
|
||||||
|
_, h, sym := parse(t, p)
|
||||||
|
res, err := tb.Add(testKey{"a", h.FragID}, "a", now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
if res != nil {
|
||||||
|
// The table keeps no memory of completed messages, so a late
|
||||||
|
// duplicate can complete one again; the handshake layer
|
||||||
|
// recognises the repeat.
|
||||||
|
require.True(t, bytes.Equal(msg, res.Msg))
|
||||||
|
got = res
|
||||||
|
}
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
}
|
||||||
|
now = now.Add(100 * time.Millisecond)
|
||||||
|
}
|
||||||
|
require.Positive(t, got.Received)
|
||||||
|
// Late fragments of a completed message start a fresh entry; drop it.
|
||||||
|
tb.Expire(now.Add(time.Hour))
|
||||||
|
}
|
||||||
|
assert.Zero(t, tb.Len())
|
||||||
|
assert.Zero(t, tb.Bytes())
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestConcurrent spreads each message's fragments across goroutines, as
|
||||||
|
// multiple UDP reader routines would.
|
||||||
|
func TestConcurrent(t *testing.T) {
|
||||||
|
tb := NewTable[testKey, string](testConfig())
|
||||||
|
now := time.Unix(1000, 0)
|
||||||
|
r := rand.New(rand.NewPCG(3, 3))
|
||||||
|
|
||||||
|
const msgs = 50
|
||||||
|
want := make(map[uint32][]byte, msgs)
|
||||||
|
var pkts [][]byte
|
||||||
|
for id := uint32(1); id <= msgs; id++ {
|
||||||
|
msg := randMsg(r, 1+r.IntN(16384))
|
||||||
|
want[id] = msg
|
||||||
|
s, err := NewSender(msg, testSubtype, 0, 1, id)
|
||||||
|
require.NoError(t, err)
|
||||||
|
a, b, err := s.Attempt(DefaultRepair(s.Layout().K))
|
||||||
|
require.NoError(t, err)
|
||||||
|
pkts = append(pkts, a...)
|
||||||
|
pkts = append(pkts, b...)
|
||||||
|
}
|
||||||
|
r.Shuffle(len(pkts), func(i, j int) { pkts[i], pkts[j] = pkts[j], pkts[i] })
|
||||||
|
|
||||||
|
var mu sync.Mutex
|
||||||
|
done := map[uint32]bool{}
|
||||||
|
var wg sync.WaitGroup
|
||||||
|
for w := range 8 {
|
||||||
|
wg.Go(func() {
|
||||||
|
for i := w; i < len(pkts); i += 8 {
|
||||||
|
h, sym, err := Parse(pkts[i][16:])
|
||||||
|
if err != nil {
|
||||||
|
t.Error(err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
src := string(rune('a' + h.FragID))
|
||||||
|
res, err := tb.Add(testKey{src, h.FragID}, src, now, h, sym)
|
||||||
|
if err != nil {
|
||||||
|
t.Error(err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if res != nil {
|
||||||
|
if !bytes.Equal(want[h.FragID], res.Msg) {
|
||||||
|
t.Errorf("message %d decoded wrong", h.FragID)
|
||||||
|
}
|
||||||
|
mu.Lock()
|
||||||
|
done[h.FragID] = true
|
||||||
|
mu.Unlock()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
wg.Wait()
|
||||||
|
assert.Len(t, done, msgs)
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
}
|
||||||
|
|
||||||
|
func firstFragment(t *testing.T, msgLen int, fragID uint32) (Header, []byte) {
|
||||||
|
t.Helper()
|
||||||
|
s, err := NewSender(make([]byte, msgLen), testSubtype, 0, 1, fragID)
|
||||||
|
require.NoError(t, err)
|
||||||
|
now, _, err := s.Attempt(0)
|
||||||
|
require.NoError(t, err)
|
||||||
|
_, h, sym := parse(t, now[0])
|
||||||
|
return h, sym
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestTableLimits(t *testing.T) {
|
||||||
|
now := time.Unix(1000, 0)
|
||||||
|
|
||||||
|
t.Run("max message length", func(t *testing.T) {
|
||||||
|
tb := NewTable[testKey, string](testConfig())
|
||||||
|
h, sym := firstFragment(t, 16385, 1)
|
||||||
|
_, err := tb.Add(testKey{"a", 1}, "a", now, h, sym)
|
||||||
|
require.ErrorIs(t, err, ErrTooLarge)
|
||||||
|
assert.Zero(t, tb.Len())
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("per source quota", func(t *testing.T) {
|
||||||
|
cfg := testConfig()
|
||||||
|
cfg.MaxPerSource = 2
|
||||||
|
tb := NewTable[testKey, string](cfg)
|
||||||
|
for id := uint32(1); id <= 3; id++ {
|
||||||
|
h, sym := firstFragment(t, 5000, id)
|
||||||
|
_, err := tb.Add(testKey{"a", id}, "a", now, h, sym)
|
||||||
|
if id <= 2 {
|
||||||
|
require.NoError(t, err)
|
||||||
|
} else {
|
||||||
|
require.ErrorIs(t, err, ErrSourceQuota)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
h, sym := firstFragment(t, 5000, 4)
|
||||||
|
_, err := tb.Add(testKey{"b", 4}, "b", now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, 3, tb.Len())
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("max entries evicts", func(t *testing.T) {
|
||||||
|
cfg := testConfig()
|
||||||
|
cfg.MaxEntries = 4
|
||||||
|
tb := NewTable[testKey, string](cfg)
|
||||||
|
for id := uint32(1); id <= 10; id++ {
|
||||||
|
h, sym := firstFragment(t, 5000, id)
|
||||||
|
src := string(rune('a' + id))
|
||||||
|
_, err := tb.Add(testKey{src, id}, src, now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
}
|
||||||
|
assert.Equal(t, 4, tb.Len())
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("max bytes evicts others", func(t *testing.T) {
|
||||||
|
cfg := testConfig()
|
||||||
|
cfg.MaxBytes = 3 * 1000
|
||||||
|
tb := NewTable[testKey, string](cfg)
|
||||||
|
for id := uint32(1); id <= 10; id++ {
|
||||||
|
h, sym := firstFragment(t, 5000, id) // 5 symbols of 1000
|
||||||
|
src := string(rune('a' + id))
|
||||||
|
_, err := tb.Add(testKey{src, id}, src, now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
}
|
||||||
|
assert.Equal(t, 3000, tb.Bytes())
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("no room removes new entry", func(t *testing.T) {
|
||||||
|
cfg := testConfig()
|
||||||
|
cfg.MaxBytes = 500
|
||||||
|
tb := NewTable[testKey, string](cfg)
|
||||||
|
h, sym := firstFragment(t, 5000, 1)
|
||||||
|
_, err := tb.Add(testKey{"a", 1}, "a", now, h, sym)
|
||||||
|
require.ErrorIs(t, err, ErrNoRoom)
|
||||||
|
assert.Zero(t, tb.Len())
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("duplicates are not charged", func(t *testing.T) {
|
||||||
|
tb := NewTable[testKey, string](testConfig())
|
||||||
|
h, sym := firstFragment(t, 5000, 1)
|
||||||
|
for range 5 {
|
||||||
|
_, err := tb.Add(testKey{"a", 1}, "a", now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
}
|
||||||
|
assert.Equal(t, 1000, tb.Bytes())
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("mismatch drops the entry", func(t *testing.T) {
|
||||||
|
tb := NewTable[testKey, string](testConfig())
|
||||||
|
h, sym := firstFragment(t, 5000, 1)
|
||||||
|
_, err := tb.Add(testKey{"a", 1}, "a", now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
h2, sym2 := firstFragment(t, 6000, 1)
|
||||||
|
_, err = tb.Add(testKey{"a", 1}, "a", now, h2, sym2)
|
||||||
|
require.ErrorIs(t, err, ErrMismatch)
|
||||||
|
assert.Zero(t, tb.Len())
|
||||||
|
assert.Zero(t, tb.Bytes())
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("load", func(t *testing.T) {
|
||||||
|
cfg := testConfig()
|
||||||
|
cfg.MaxEntries = 4
|
||||||
|
cfg.MaxBytes = 10000
|
||||||
|
tb := NewTable[testKey, string](cfg)
|
||||||
|
assert.Zero(t, tb.Load())
|
||||||
|
h, sym := firstFragment(t, 5000, 1)
|
||||||
|
_, err := tb.Add(testKey{"a", 1}, "a", now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.InDelta(t, 0.25, tb.Load(), 0.001, "one of four entries")
|
||||||
|
h, sym = firstFragment(t, 5000, 2)
|
||||||
|
_, err = tb.Add(testKey{"b", 2}, "b", now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.InDelta(t, 0.5, tb.Load(), 0.001)
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("ttl", func(t *testing.T) {
|
||||||
|
tb := NewTable[testKey, string](testConfig())
|
||||||
|
s, err := NewSender(make([]byte, 5000), testSubtype, 0, 1, 1)
|
||||||
|
require.NoError(t, err)
|
||||||
|
pkts, _, err := s.Attempt(0)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
_, h, sym := parse(t, pkts[0])
|
||||||
|
_, err = tb.Add(testKey{"a", 1}, "a", now, h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
// Activity within the TTL keeps the entry and slides its deadline.
|
||||||
|
_, h, sym = parse(t, pkts[1])
|
||||||
|
_, err = tb.Add(testKey{"a", 1}, "a", now.Add(1500*time.Millisecond), h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, 2000, tb.Bytes())
|
||||||
|
|
||||||
|
tb.Expire(now.Add(3 * time.Second))
|
||||||
|
assert.Equal(t, 1, tb.Len())
|
||||||
|
|
||||||
|
// A stale entry is restarted rather than merged.
|
||||||
|
_, h, sym = parse(t, pkts[2])
|
||||||
|
_, err = tb.Add(testKey{"a", 1}, "a", now.Add(10*time.Second), h, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, 1000, tb.Bytes())
|
||||||
|
|
||||||
|
tb.Expire(now.Add(time.Minute))
|
||||||
|
assert.Zero(t, tb.Len())
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func FuzzParse(f *testing.F) {
|
||||||
|
f.Add(append(Header{FragID: 1, MsgLen: 3000}.Encode(nil), make([]byte, 1000)...))
|
||||||
|
f.Add([]byte{0, 0, 0, 1, 0, 1, 0, 0, 7})
|
||||||
|
f.Fuzz(func(t *testing.T, b []byte) {
|
||||||
|
h, sym, err := Parse(b)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
require.Equal(t, b, append(h.Encode(nil), sym...))
|
||||||
|
l, err := h.Layout()
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.LessOrEqual(t, l.SymbolSize, MaxSymbolSize)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// FuzzTable drives a small table with arbitrary fragments and checks its
|
||||||
|
// bookkeeping after every step.
|
||||||
|
func FuzzTable(f *testing.F) {
|
||||||
|
f.Add([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12})
|
||||||
|
f.Fuzz(func(t *testing.T, ops []byte) {
|
||||||
|
tb := NewTable[testKey, string](TableConfig{
|
||||||
|
MaxBytes: 4000,
|
||||||
|
MaxEntries: 3,
|
||||||
|
MaxPerSource: 2,
|
||||||
|
MaxMsgLen: 6000,
|
||||||
|
TTL: time.Second,
|
||||||
|
})
|
||||||
|
now := time.Unix(0, 0)
|
||||||
|
for len(ops) >= 4 {
|
||||||
|
src := string(rune('a' + ops[0]%4))
|
||||||
|
fragID := uint32(ops[1]%5) + 1
|
||||||
|
msgLen := uint16(ops[2])*32 + 1
|
||||||
|
index := ops[3]
|
||||||
|
ops = ops[4:]
|
||||||
|
|
||||||
|
h := Header{FragID: fragID, MsgLen: msgLen, Index: index}
|
||||||
|
l, err := h.Layout()
|
||||||
|
require.NoError(t, err)
|
||||||
|
sym := make([]byte, l.SymbolSize)
|
||||||
|
if index%7 == 0 {
|
||||||
|
now = now.Add(600 * time.Millisecond)
|
||||||
|
tb.Expire(now)
|
||||||
|
}
|
||||||
|
res, err := tb.Add(testKey{src, fragID}, src, now, h, sym)
|
||||||
|
if res != nil {
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Len(t, res.Msg, int(msgLen))
|
||||||
|
}
|
||||||
|
checkInvariants(t, tb)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
@@ -0,0 +1,118 @@
|
|||||||
|
package fragment
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"math"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/handshake/fec"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
)
|
||||||
|
|
||||||
|
// DefaultRepair is the starting number of repair symbols per attempt for a
|
||||||
|
// message of k data symbols. Small messages get proportionally more repair.
|
||||||
|
func DefaultRepair(k int) int {
|
||||||
|
return max(2, (k+2)/3)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sender produces the fragment packets of one outgoing handshake message.
|
||||||
|
//
|
||||||
|
// The first attempt sends the K data symbols followed by repair symbols. Every
|
||||||
|
// later attempt sends symbols with indexes the receiver has not been offered yet,
|
||||||
|
// so whatever it already holds still counts toward K. Symbols are a deterministic
|
||||||
|
// function of the message, which keeps retransmits idempotent. Once all
|
||||||
|
// fec.MaxSymbols indexes are used the sequence wraps and repeats.
|
||||||
|
//
|
||||||
|
// A Sender is not safe for concurrent use.
|
||||||
|
type Sender struct {
|
||||||
|
enc *fec.Encoder
|
||||||
|
subtype header.MessageSubType
|
||||||
|
remoteIndex uint32
|
||||||
|
counter uint64
|
||||||
|
fragID uint32
|
||||||
|
next int
|
||||||
|
cookie *Cookie
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewSender prepares msg for sending. subtype, remoteIndex and counter fill the
|
||||||
|
// Nebula header of every fragment; fragID is the sender's local index.
|
||||||
|
func NewSender(msg []byte, subtype header.MessageSubType, remoteIndex uint32, counter uint64, fragID uint32) (*Sender, error) {
|
||||||
|
if len(msg) == 0 || len(msg) > math.MaxUint16 {
|
||||||
|
return nil, ErrMsgLen
|
||||||
|
}
|
||||||
|
if fragID == 0 {
|
||||||
|
return nil, ErrFragID
|
||||||
|
}
|
||||||
|
enc, err := fec.NewEncoder(msg, MaxSymbolSize)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return &Sender{
|
||||||
|
enc: enc,
|
||||||
|
subtype: subtype,
|
||||||
|
remoteIndex: remoteIndex,
|
||||||
|
counter: counter,
|
||||||
|
fragID: fragID,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) Layout() fec.Layout {
|
||||||
|
return s.enc.Layout()
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetNext sets the index the next attempt starts from, so a sender rebuilt from
|
||||||
|
// a cached message can carry on offering fresh symbols.
|
||||||
|
func (s *Sender) SetNext(index int) {
|
||||||
|
s.next = ((index % fec.MaxSymbols) + fec.MaxSymbols) % fec.MaxSymbols
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetCookie attaches a cookie from a responder under load to every later packet.
|
||||||
|
func (s *Sender) SetCookie(c Cookie) {
|
||||||
|
s.cookie = &c
|
||||||
|
}
|
||||||
|
|
||||||
|
// Next returns the index the next attempt starts from.
|
||||||
|
func (s *Sender) Next() int {
|
||||||
|
return s.next
|
||||||
|
}
|
||||||
|
|
||||||
|
// Attempt returns the packets for one transmission attempt carrying K+repair
|
||||||
|
// symbols. now should be sent immediately and later after the repair delay, so
|
||||||
|
// a tail drop at the end of the first burst does not also take the repair.
|
||||||
|
func (s *Sender) Attempt(repair int) (now, later [][]byte, err error) {
|
||||||
|
if repair < 0 {
|
||||||
|
return nil, nil, errors.New("negative repair count")
|
||||||
|
}
|
||||||
|
k := s.enc.Layout().K
|
||||||
|
now = make([][]byte, 0, k)
|
||||||
|
later = make([][]byte, 0, repair)
|
||||||
|
for i := range k + repair {
|
||||||
|
p, err := s.packet(s.next)
|
||||||
|
if err != nil {
|
||||||
|
return nil, nil, err
|
||||||
|
}
|
||||||
|
s.next = (s.next + 1) % fec.MaxSymbols
|
||||||
|
if i < k {
|
||||||
|
now = append(now, p)
|
||||||
|
} else {
|
||||||
|
later = append(later, p)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return now, later, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) packet(index int) ([]byte, error) {
|
||||||
|
l := s.enc.Layout()
|
||||||
|
p := make([]byte, header.Len, header.Len+HeaderLen+CookieLen+l.SymbolSize)
|
||||||
|
header.Encode(p, header.Version, header.Handshake, s.subtype, s.remoteIndex, s.counter)
|
||||||
|
h := Header{
|
||||||
|
FragID: s.fragID,
|
||||||
|
MsgLen: uint16(l.MsgLen),
|
||||||
|
Index: uint8(index),
|
||||||
|
}
|
||||||
|
if s.cookie != nil {
|
||||||
|
h.Flags |= FlagCookie
|
||||||
|
h.Cookie = *s.cookie
|
||||||
|
}
|
||||||
|
p = h.Encode(p)
|
||||||
|
return s.enc.Symbol(p, index)
|
||||||
|
}
|
||||||
@@ -0,0 +1,220 @@
|
|||||||
|
package fragment
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"math/rand/v2"
|
||||||
|
"sync"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
ErrTooLarge = errors.New("fragmented message exceeds the size limit")
|
||||||
|
ErrSourceQuota = errors.New("source has too many messages in progress")
|
||||||
|
ErrNoRoom = errors.New("no room for fragment")
|
||||||
|
)
|
||||||
|
|
||||||
|
// TableConfig bounds a Table.
|
||||||
|
type TableConfig struct {
|
||||||
|
MaxBytes int // symbol bytes held across all entries
|
||||||
|
MaxEntries int // messages in progress across all sources
|
||||||
|
MaxPerSource int // messages in progress per source
|
||||||
|
MaxMsgLen int // largest message accepted
|
||||||
|
TTL time.Duration // an entry idle this long is dropped
|
||||||
|
}
|
||||||
|
|
||||||
|
// Table reassembles messages from senders that have not authenticated yet, the
|
||||||
|
// responder's view of msg1. Every resource is capped. When a cap is hit a
|
||||||
|
// random entry is evicted; random eviction is harder to aim than LRU, which a
|
||||||
|
// flood can use to flush specific entries.
|
||||||
|
//
|
||||||
|
// K identifies one message, typically the source plus FragID. S identifies the
|
||||||
|
// source for quotas, typically the address masked to /32 or /64.
|
||||||
|
//
|
||||||
|
// A Table is safe for concurrent use.
|
||||||
|
type Table[K, S comparable] struct {
|
||||||
|
mu sync.Mutex
|
||||||
|
cfg TableConfig
|
||||||
|
entries map[K]*tableEntry[K, S]
|
||||||
|
order []K
|
||||||
|
perSource map[S]int
|
||||||
|
bytes int
|
||||||
|
}
|
||||||
|
|
||||||
|
type tableEntry[K, S comparable] struct {
|
||||||
|
a *Assembly
|
||||||
|
source S
|
||||||
|
lastSeen time.Time
|
||||||
|
pos int
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewTable[K, S comparable](cfg TableConfig) *Table[K, S] {
|
||||||
|
return &Table[K, S]{
|
||||||
|
cfg: cfg,
|
||||||
|
entries: make(map[K]*tableEntry[K, S]),
|
||||||
|
perSource: make(map[S]int),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Result describes a completed message.
|
||||||
|
type Result struct {
|
||||||
|
Msg []byte // the decoded message
|
||||||
|
Received int // packet bytes received for it, for the amplification budget
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add records a fragment parsed by Parse. When the message is complete its entry
|
||||||
|
// is removed and the result returned; otherwise the result is nil. A decode
|
||||||
|
// error means the message is lost and must be retransmitted.
|
||||||
|
func (t *Table[K, S]) Add(key K, source S, now time.Time, h Header, sym []byte) (*Result, error) {
|
||||||
|
if int(h.MsgLen) > t.cfg.MaxMsgLen {
|
||||||
|
return nil, ErrTooLarge
|
||||||
|
}
|
||||||
|
|
||||||
|
t.mu.Lock()
|
||||||
|
e, ok := t.entries[key]
|
||||||
|
if ok && now.Sub(e.lastSeen) > t.cfg.TTL {
|
||||||
|
t.remove(key, e)
|
||||||
|
ok = false
|
||||||
|
}
|
||||||
|
if !ok {
|
||||||
|
var err error
|
||||||
|
e, err = t.insert(key, source, h)
|
||||||
|
if err != nil {
|
||||||
|
t.mu.Unlock()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
e.lastSeen = now
|
||||||
|
|
||||||
|
if !t.makeRoom(key, e.a.wouldStore(h, sym)) {
|
||||||
|
if e.a.Stored() == 0 {
|
||||||
|
t.remove(key, e)
|
||||||
|
}
|
||||||
|
t.mu.Unlock()
|
||||||
|
return nil, ErrNoRoom
|
||||||
|
}
|
||||||
|
|
||||||
|
before := e.a.Stored()
|
||||||
|
ready, err := e.a.Add(h, sym)
|
||||||
|
t.bytes += e.a.Stored() - before
|
||||||
|
if err != nil || !ready {
|
||||||
|
if errors.Is(err, ErrMismatch) || (err != nil && e.a.Stored() == 0) {
|
||||||
|
t.remove(key, e)
|
||||||
|
}
|
||||||
|
t.mu.Unlock()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
t.remove(key, e)
|
||||||
|
t.mu.Unlock()
|
||||||
|
|
||||||
|
msg, err := e.a.Decode()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return &Result{Msg: msg, Received: e.a.Received()}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Expire drops every entry idle for longer than the TTL.
|
||||||
|
func (t *Table[K, S]) Expire(now time.Time) {
|
||||||
|
t.mu.Lock()
|
||||||
|
defer t.mu.Unlock()
|
||||||
|
for i := 0; i < len(t.order); {
|
||||||
|
key := t.order[i]
|
||||||
|
e := t.entries[key]
|
||||||
|
if now.Sub(e.lastSeen) > t.cfg.TTL {
|
||||||
|
// remove swaps the last entry into position i, so look at i again.
|
||||||
|
t.remove(key, e)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Len returns the number of messages in progress.
|
||||||
|
func (t *Table[K, S]) Len() int {
|
||||||
|
t.mu.Lock()
|
||||||
|
defer t.mu.Unlock()
|
||||||
|
return len(t.entries)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Load returns how full the table is, from 0 to 1, by whichever of its byte and
|
||||||
|
// entry limits is closer.
|
||||||
|
func (t *Table[K, S]) Load() float64 {
|
||||||
|
t.mu.Lock()
|
||||||
|
defer t.mu.Unlock()
|
||||||
|
return max(float64(t.bytes)/float64(t.cfg.MaxBytes), float64(len(t.entries))/float64(t.cfg.MaxEntries))
|
||||||
|
}
|
||||||
|
|
||||||
|
// Bytes returns the number of symbol bytes held.
|
||||||
|
func (t *Table[K, S]) Bytes() int {
|
||||||
|
t.mu.Lock()
|
||||||
|
defer t.mu.Unlock()
|
||||||
|
return t.bytes
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t *Table[K, S]) insert(key K, source S, h Header) (*tableEntry[K, S], error) {
|
||||||
|
if t.perSource[source] >= t.cfg.MaxPerSource {
|
||||||
|
return nil, ErrSourceQuota
|
||||||
|
}
|
||||||
|
a, err := NewAssembly(h)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
for len(t.entries) >= t.cfg.MaxEntries {
|
||||||
|
if !t.evictRandom(nil) {
|
||||||
|
return nil, ErrNoRoom
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
e := &tableEntry[K, S]{a: a, source: source, pos: len(t.order)}
|
||||||
|
t.entries[key] = e
|
||||||
|
t.order = append(t.order, key)
|
||||||
|
t.perSource[source]++
|
||||||
|
return e, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// makeRoom evicts random entries other than keep until n more bytes fit.
|
||||||
|
func (t *Table[K, S]) makeRoom(keep K, n int) bool {
|
||||||
|
for t.bytes+n > t.cfg.MaxBytes {
|
||||||
|
if !t.evictRandom(&keep) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t *Table[K, S]) evictRandom(keep *K) bool {
|
||||||
|
candidates := len(t.order)
|
||||||
|
if keep != nil {
|
||||||
|
if _, ok := t.entries[*keep]; ok {
|
||||||
|
candidates--
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if candidates <= 0 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
for {
|
||||||
|
key := t.order[rand.IntN(len(t.order))]
|
||||||
|
if keep != nil && key == *keep {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
t.remove(key, t.entries[key])
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (t *Table[K, S]) remove(key K, e *tableEntry[K, S]) {
|
||||||
|
last := len(t.order) - 1
|
||||||
|
moved := t.order[last]
|
||||||
|
t.order[e.pos] = moved
|
||||||
|
t.entries[moved].pos = e.pos
|
||||||
|
t.order = t.order[:last]
|
||||||
|
delete(t.entries, key)
|
||||||
|
|
||||||
|
t.bytes -= e.a.Stored()
|
||||||
|
if t.perSource[e.source] <= 1 {
|
||||||
|
delete(t.perSource, e.source)
|
||||||
|
} else {
|
||||||
|
t.perSource[e.source]--
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,121 @@
|
|||||||
|
// Package fragment carries handshake messages that do not fit in one UDP
|
||||||
|
// packet. A message is Reed-Solomon coded into equally sized symbols (see
|
||||||
|
// handshake/fec) and each symbol travels in its own packet:
|
||||||
|
//
|
||||||
|
// Nebula header (16) | Fragment header (8) | [cookie (16)] | symbol
|
||||||
|
//
|
||||||
|
// The fragment header is FragID u32 | MsgLen u16 | Index u8 | Flags u8, all big
|
||||||
|
// endian. Both ends derive the symbol layout from MsgLen, so any MsgLen-derived
|
||||||
|
// value never has to be sent. FlagCookie marks a cookie a responder under load
|
||||||
|
// asked for; room for it is always reserved, so a fragment never outgrows
|
||||||
|
// MaxPacketLen.
|
||||||
|
package fragment
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"errors"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/handshake/fec"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
// HeaderLen is the size of the fragment header that follows the Nebula header.
|
||||||
|
HeaderLen = 8
|
||||||
|
|
||||||
|
// CookieLen is the size of the cookie a fragment carries when FlagCookie is set.
|
||||||
|
CookieLen = 16
|
||||||
|
|
||||||
|
// FlagCookie marks a fragment that carries a cookie after its header.
|
||||||
|
FlagCookie uint8 = 0x01
|
||||||
|
|
||||||
|
// MaxPacketLen bounds every fragment packet, Nebula header included. A relayed
|
||||||
|
// fragment gains a 16 byte header and a 16 byte tag, which lands exactly on
|
||||||
|
// the 1232 byte UDP payload available on an IPv6 minimum MTU path.
|
||||||
|
MaxPacketLen = 1200
|
||||||
|
|
||||||
|
// MaxSymbolSize is the largest symbol that fits in MaxPacketLen alongside a cookie.
|
||||||
|
MaxSymbolSize = MaxPacketLen - header.Len - HeaderLen - CookieLen
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
ErrShortFragment = errors.New("fragment is too short")
|
||||||
|
ErrFragID = errors.New("fragment has a zero FragID")
|
||||||
|
ErrMsgLen = errors.New("fragment has a zero MsgLen")
|
||||||
|
ErrFlags = errors.New("fragment has reserved flags set")
|
||||||
|
ErrNoCookie = errors.New("fragment is too short for its cookie")
|
||||||
|
ErrSymbolSize = errors.New("fragment symbol size does not match its MsgLen")
|
||||||
|
)
|
||||||
|
|
||||||
|
// Cookie proves a sender received a responder's reply at its address.
|
||||||
|
type Cookie [CookieLen]byte
|
||||||
|
|
||||||
|
// Header is the fragment header.
|
||||||
|
type Header struct {
|
||||||
|
FragID uint32 // the sender's local index for this handshake, never zero
|
||||||
|
MsgLen uint16 // length of the whole message
|
||||||
|
Index uint8 // symbol index, data below K and repair from K
|
||||||
|
Flags uint8 // FlagCookie, other bits reserved and zero
|
||||||
|
Cookie Cookie // valid when Flags has FlagCookie
|
||||||
|
}
|
||||||
|
|
||||||
|
func (h Header) HasCookie() bool {
|
||||||
|
return h.Flags&FlagCookie != 0
|
||||||
|
}
|
||||||
|
|
||||||
|
// Encode appends the header, and its cookie if it has one, to b.
|
||||||
|
func (h Header) Encode(b []byte) []byte {
|
||||||
|
b = binary.BigEndian.AppendUint32(b, h.FragID)
|
||||||
|
b = binary.BigEndian.AppendUint16(b, h.MsgLen)
|
||||||
|
b = append(b, h.Index, h.Flags)
|
||||||
|
if h.HasCookie() {
|
||||||
|
b = append(b, h.Cookie[:]...)
|
||||||
|
}
|
||||||
|
return b
|
||||||
|
}
|
||||||
|
|
||||||
|
// Layout returns the symbol layout the header's MsgLen implies.
|
||||||
|
func (h Header) Layout() (fec.Layout, error) {
|
||||||
|
return fec.NewLayout(int(h.MsgLen), MaxSymbolSize)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parse validates the bytes following the Nebula header and splits them into
|
||||||
|
// the fragment header and the symbol. The symbol aliases b.
|
||||||
|
func Parse(b []byte) (Header, []byte, error) {
|
||||||
|
if len(b) < HeaderLen {
|
||||||
|
return Header{}, nil, ErrShortFragment
|
||||||
|
}
|
||||||
|
h := Header{
|
||||||
|
FragID: binary.BigEndian.Uint32(b[0:4]),
|
||||||
|
MsgLen: binary.BigEndian.Uint16(b[4:6]),
|
||||||
|
Index: b[6],
|
||||||
|
Flags: b[7],
|
||||||
|
}
|
||||||
|
if h.FragID == 0 {
|
||||||
|
return Header{}, nil, ErrFragID
|
||||||
|
}
|
||||||
|
if h.MsgLen == 0 {
|
||||||
|
return Header{}, nil, ErrMsgLen
|
||||||
|
}
|
||||||
|
if h.Flags&^FlagCookie != 0 {
|
||||||
|
return Header{}, nil, ErrFlags
|
||||||
|
}
|
||||||
|
b = b[HeaderLen:]
|
||||||
|
if h.HasCookie() {
|
||||||
|
if len(b) < CookieLen {
|
||||||
|
return Header{}, nil, ErrNoCookie
|
||||||
|
}
|
||||||
|
copy(h.Cookie[:], b)
|
||||||
|
b = b[CookieLen:]
|
||||||
|
}
|
||||||
|
|
||||||
|
l, err := h.Layout()
|
||||||
|
if err != nil {
|
||||||
|
return Header{}, nil, err
|
||||||
|
}
|
||||||
|
sym := b
|
||||||
|
if len(sym) != l.SymbolSize {
|
||||||
|
return Header{}, nil, ErrSymbolSize
|
||||||
|
}
|
||||||
|
return h, sym, nil
|
||||||
|
}
|
||||||
@@ -24,6 +24,9 @@ message NebulaHandshakeDetails {
|
|||||||
uint64 Cookie = 4 [deprecated = true];
|
uint64 Cookie = 4 [deprecated = true];
|
||||||
uint64 Time = 5;
|
uint64 Time = 5;
|
||||||
uint32 CertVersion = 8;
|
uint32 CertVersion = 8;
|
||||||
|
// KEMKey is the initiator's ephemeral ML-KEM-1024 encapsulation key. It is
|
||||||
|
// only present in msg1 of the ix_psk2_mlkem1024 subtype.
|
||||||
|
bytes KEMKey = 9;
|
||||||
// reserved for WIP multiport
|
// reserved for WIP multiport
|
||||||
reserved 6, 7;
|
reserved 6, 7;
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,68 @@
|
|||||||
|
package handshake
|
||||||
|
|
||||||
|
import (
|
||||||
|
"crypto/hkdf"
|
||||||
|
"crypto/mlkem"
|
||||||
|
"crypto/sha256"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
)
|
||||||
|
|
||||||
|
// kemPSKSalt separates the psk derivation from any other use of the secret.
|
||||||
|
const kemPSKSalt = "nebula ix_psk2_mlkem1024 v1"
|
||||||
|
|
||||||
|
var ErrInvalidKEMKey = errors.New("peer sent an invalid ML-KEM encapsulation key")
|
||||||
|
|
||||||
|
// kemPSK derives the noise psk from an ML-KEM shared secret. The ciphertext is
|
||||||
|
// bound in because, unlike the encapsulation key, it travels outside the noise
|
||||||
|
// transcript.
|
||||||
|
func kemPSK(sharedKey, ciphertext []byte) ([]byte, error) {
|
||||||
|
secret := make([]byte, 0, len(sharedKey)+len(ciphertext))
|
||||||
|
secret = append(secret, sharedKey...)
|
||||||
|
secret = append(secret, ciphertext...)
|
||||||
|
return hkdf.Extract(sha256.New, secret, []byte(kemPSKSalt))
|
||||||
|
}
|
||||||
|
|
||||||
|
// kemEncapsulate is the responder half: encapsulate to the initiator's key,
|
||||||
|
// install the psk, and remember the ciphertext to prefix the response with.
|
||||||
|
func (m *Machine) kemEncapsulate(encapsulationKey []byte) error {
|
||||||
|
ek, err := mlkem.NewEncapsulationKey1024(encapsulationKey)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("%w: %w", ErrInvalidKEMKey, err)
|
||||||
|
}
|
||||||
|
sharedKey, ct := ek.Encapsulate()
|
||||||
|
psk, err := kemPSK(sharedKey, ct)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err := m.hs.SetPresharedKey(psk); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
m.kemCiphertext = ct
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// kemDecapsulate is the initiator half: recover the shared secret from the
|
||||||
|
// ciphertext prefixing the response and install the psk. It returns the rest of
|
||||||
|
// the message, which is the noise message.
|
||||||
|
func (m *Machine) kemDecapsulate(msg []byte) ([]byte, error) {
|
||||||
|
if len(msg) < mlkem.CiphertextSize1024 {
|
||||||
|
return nil, ErrPacketTooShort
|
||||||
|
}
|
||||||
|
if m.kemKey == nil {
|
||||||
|
return nil, errors.New("no ML-KEM decapsulation key for this handshake")
|
||||||
|
}
|
||||||
|
ct := msg[:mlkem.CiphertextSize1024]
|
||||||
|
sharedKey, err := m.kemKey.Decapsulate(ct)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
psk, err := kemPSK(sharedKey, ct)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
if err := m.hs.SetPresharedKey(psk); err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return msg[mlkem.CiphertextSize1024:], nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,208 @@
|
|||||||
|
package handshake
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"crypto/mlkem"
|
||||||
|
"net/netip"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/flynn/noise"
|
||||||
|
"github.com/slackhq/nebula/cert"
|
||||||
|
ct "github.com/slackhq/nebula/cert_test"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
)
|
||||||
|
|
||||||
|
func newKEMMachine(t *testing.T, cs *testCertState, v CertVerifier, initiator bool, index uint32) *Machine {
|
||||||
|
t.Helper()
|
||||||
|
m, err := NewMachine(
|
||||||
|
cs.version, cs.getCredential, v,
|
||||||
|
func() (uint32, error) { return index, nil },
|
||||||
|
initiator, header.HandshakeIXPSK2MLKEM1024,
|
||||||
|
)
|
||||||
|
require.NoError(t, err)
|
||||||
|
return m
|
||||||
|
}
|
||||||
|
|
||||||
|
type kemFixture struct {
|
||||||
|
initCS, respCS *testCertState
|
||||||
|
v CertVerifier
|
||||||
|
}
|
||||||
|
|
||||||
|
func newKEMFixture(t *testing.T, cipher noise.CipherFunc) kemFixture {
|
||||||
|
ca, _, caKey, _ := ct.NewTestCaCert(
|
||||||
|
cert.Version2, cert.Curve_CURVE25519, time.Time{}, time.Time{}, nil, nil, nil,
|
||||||
|
)
|
||||||
|
return kemFixture{
|
||||||
|
initCS: newTestCertStateWithCipher(t, ca, caKey, "initiator", []netip.Prefix{netip.MustParsePrefix("10.0.0.1/24")}, cipher),
|
||||||
|
respCS: newTestCertStateWithCipher(t, ca, caKey, "responder", []netip.Prefix{netip.MustParsePrefix("10.0.0.2/24")}, cipher),
|
||||||
|
v: testVerifier(ct.NewTestCAPool(ca)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func requireKeysMatch(t *testing.T, a, b *Result) {
|
||||||
|
t.Helper()
|
||||||
|
c, err := a.EKey.Encrypt(nil, nil, []byte("hello"))
|
||||||
|
require.NoError(t, err)
|
||||||
|
p, err := b.DKey.Decrypt(nil, nil, c)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []byte("hello"), p)
|
||||||
|
|
||||||
|
c, err = b.EKey.Encrypt(nil, nil, []byte("world"))
|
||||||
|
require.NoError(t, err)
|
||||||
|
p, err = a.DKey.Decrypt(nil, nil, c)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, []byte("world"), p)
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestKEMHandshake(t *testing.T) {
|
||||||
|
for _, cipher := range []noise.CipherFunc{noise.CipherChaChaPoly, noise.CipherAESGCM} {
|
||||||
|
t.Run(cipher.CipherName(), func(t *testing.T) {
|
||||||
|
f := newKEMFixture(t, cipher)
|
||||||
|
initM := newKEMMachine(t, f.initCS, f.v, true, 1000)
|
||||||
|
respM := newKEMMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
|
||||||
|
msg1, err := initM.Initiate(nil)
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, header.HandshakeIXPSK2MLKEM1024, header.MessageSubType(msg1[1]))
|
||||||
|
assert.Greater(t, len(msg1), header.Len+mlkem.EncapsulationKeySize1024)
|
||||||
|
|
||||||
|
msg2, respR, err := respM.ProcessPacket(nil, msg1)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.NotNil(t, respR)
|
||||||
|
assert.Greater(t, len(msg2), header.Len+mlkem.CiphertextSize1024)
|
||||||
|
|
||||||
|
_, initR, err := initM.ProcessPacket(nil, msg2)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.NotNil(t, initR)
|
||||||
|
|
||||||
|
assert.Equal(t, "responder", initR.RemoteCert.Certificate.Name())
|
||||||
|
assert.Equal(t, "initiator", respR.RemoteCert.Certificate.Name())
|
||||||
|
assert.Equal(t, uint32(2000), initR.RemoteIndex)
|
||||||
|
assert.Equal(t, uint32(1000), respR.RemoteIndex)
|
||||||
|
requireKeysMatch(t, initR, respR)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestKEMSecretMatters checks the ML-KEM secret really reaches the transport
|
||||||
|
// keys: an initiator holding a different decapsulation key cannot complete even
|
||||||
|
// though every DH input is genuine.
|
||||||
|
func TestKEMSecretMatters(t *testing.T) {
|
||||||
|
f := newKEMFixture(t, noise.CipherChaChaPoly)
|
||||||
|
initM := newKEMMachine(t, f.initCS, f.v, true, 1000)
|
||||||
|
respM := newKEMMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
|
||||||
|
msg1, err := initM.Initiate(nil)
|
||||||
|
require.NoError(t, err)
|
||||||
|
msg2, _, err := respM.ProcessPacket(nil, msg1)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
other, err := mlkem.GenerateKey1024()
|
||||||
|
require.NoError(t, err)
|
||||||
|
initM.kemKey = other
|
||||||
|
|
||||||
|
_, res, err := initM.ProcessPacket(nil, msg2)
|
||||||
|
require.Error(t, err)
|
||||||
|
assert.Nil(t, res)
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestKEMTamperedCiphertext(t *testing.T) {
|
||||||
|
f := newKEMFixture(t, noise.CipherChaChaPoly)
|
||||||
|
initM := newKEMMachine(t, f.initCS, f.v, true, 1000)
|
||||||
|
respM := newKEMMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
|
||||||
|
msg1, err := initM.Initiate(nil)
|
||||||
|
require.NoError(t, err)
|
||||||
|
msg2, respR, err := respM.ProcessPacket(nil, msg1)
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
t.Run("truncated", func(t *testing.T) {
|
||||||
|
_, res, err := initM.ProcessPacket(nil, msg2[:header.Len+mlkem.CiphertextSize1024-1])
|
||||||
|
require.ErrorIs(t, err, ErrPacketTooShort)
|
||||||
|
assert.Nil(t, res)
|
||||||
|
assert.False(t, initM.Failed())
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("flipped ciphertext bit", func(t *testing.T) {
|
||||||
|
bad := bytes.Clone(msg2)
|
||||||
|
bad[header.Len+10] ^= 1
|
||||||
|
_, res, err := initM.ProcessPacket(nil, bad)
|
||||||
|
require.Error(t, err)
|
||||||
|
assert.Nil(t, res)
|
||||||
|
assert.False(t, initM.Failed(), "a forged ciphertext must not kill the handshake")
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("genuine response still completes", func(t *testing.T) {
|
||||||
|
_, initR, err := initM.ProcessPacket(nil, msg2)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.NotNil(t, initR)
|
||||||
|
requireKeysMatch(t, initR, respR)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestKEMBadMsg1 drives processPayload by hand. With the psk modifier msg1's
|
||||||
|
// payload is encrypted under a key derived from the public ephemeral, so a
|
||||||
|
// forged payload would need re-encrypting; the parsing rules are what matter.
|
||||||
|
func TestKEMBadMsg1(t *testing.T) {
|
||||||
|
f := newKEMFixture(t, noise.CipherChaChaPoly)
|
||||||
|
msg1Flags := subtypeInfos[header.HandshakeIXPSK2MLKEM1024].msgs[0]
|
||||||
|
cert := f.initCS.creds[cert.Version2]
|
||||||
|
payload := func(kemKey []byte) []byte {
|
||||||
|
return MarshalPayload(nil, Payload{
|
||||||
|
Cert: cert.Bytes,
|
||||||
|
CertVersion: uint32(cert.Cert.Version()),
|
||||||
|
InitiatorIndex: 1000,
|
||||||
|
Time: 1,
|
||||||
|
KEMKey: kemKey,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
dk, err := mlkem.GenerateKey1024()
|
||||||
|
require.NoError(t, err)
|
||||||
|
|
||||||
|
t.Run("missing KEM key", func(t *testing.T) {
|
||||||
|
m := newKEMMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
err := m.processPayload(payload(nil), msg1Flags)
|
||||||
|
require.ErrorIs(t, err, ErrUnexpectedContent)
|
||||||
|
assert.True(t, m.Failed())
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("invalid KEM key", func(t *testing.T) {
|
||||||
|
m := newKEMMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
// Coefficients of 0xfff exceed the modulus, which ML-KEM must reject.
|
||||||
|
bad := bytes.Repeat([]byte{0xff}, mlkem.EncapsulationKeySize1024)
|
||||||
|
err := m.kemEncapsulate(bad)
|
||||||
|
require.ErrorIs(t, err, ErrInvalidKEMKey)
|
||||||
|
err = m.kemEncapsulate(bad[:100])
|
||||||
|
require.ErrorIs(t, err, ErrInvalidKEMKey)
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("valid KEM key", func(t *testing.T) {
|
||||||
|
m := newKEMMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
require.NoError(t, m.kemEncapsulate(dk.EncapsulationKey().Bytes()))
|
||||||
|
assert.Len(t, m.kemCiphertext, mlkem.CiphertextSize1024)
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("KEM key on the classical subtype", func(t *testing.T) {
|
||||||
|
m := newTestMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
classical := subtypeInfos[header.HandshakeIXPSK0].msgs[0]
|
||||||
|
err := m.processPayload(payload(dk.EncapsulationKey().Bytes()), classical)
|
||||||
|
require.ErrorIs(t, err, ErrUnexpectedContent)
|
||||||
|
assert.True(t, m.Failed())
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// TestKEMDistinctFromClassical makes sure the two subtypes cannot be mixed: a
|
||||||
|
// classical responder cannot answer a KEM initiator.
|
||||||
|
func TestKEMDistinctFromClassical(t *testing.T) {
|
||||||
|
f := newKEMFixture(t, noise.CipherChaChaPoly)
|
||||||
|
initM := newKEMMachine(t, f.initCS, f.v, true, 1000)
|
||||||
|
respM := newTestMachine(t, f.respCS, f.v, false, 2000)
|
||||||
|
|
||||||
|
msg1, err := initM.Initiate(nil)
|
||||||
|
require.NoError(t, err)
|
||||||
|
_, _, err = respM.ProcessPacket(nil, msg1)
|
||||||
|
require.ErrorIs(t, err, ErrSubtypeMismatch)
|
||||||
|
}
|
||||||
+54
-5
@@ -2,6 +2,8 @@ package handshake
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"bytes"
|
"bytes"
|
||||||
|
"crypto/mlkem"
|
||||||
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"slices"
|
"slices"
|
||||||
"time"
|
"time"
|
||||||
@@ -67,6 +69,9 @@ type Machine struct {
|
|||||||
remoteCertSet bool
|
remoteCertSet bool
|
||||||
payloadSet bool
|
payloadSet bool
|
||||||
failed bool
|
failed bool
|
||||||
|
|
||||||
|
kemKey *mlkem.DecapsulationKey1024 // initiator's ephemeral ML-KEM key, until completion
|
||||||
|
kemCiphertext []byte // responder's ciphertext to prefix its response with
|
||||||
}
|
}
|
||||||
|
|
||||||
// NewMachine creates a handshake state machine. The subtype determines both
|
// NewMachine creates a handshake state machine. The subtype determines both
|
||||||
@@ -91,7 +96,7 @@ func NewMachine(
|
|||||||
return nil, fmt.Errorf("%w: %v", ErrNoCredential, version)
|
return nil, fmt.Errorf("%w: %v", ErrNoCredential, version)
|
||||||
}
|
}
|
||||||
|
|
||||||
hs, err := cred.buildHandshakeState(initiator, info.pattern)
|
hs, err := cred.buildHandshakeState(initiator, info.pattern, info.pskPlacement)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, fmt.Errorf("build noise state: %w", err)
|
return nil, fmt.Errorf("build noise state: %w", err)
|
||||||
}
|
}
|
||||||
@@ -137,7 +142,8 @@ func (m *Machine) requireComplete() error {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// myMsgFlags returns the flags for the current outgoing message.
|
// myMsgFlags returns the flags for the current outgoing message, which are
|
||||||
|
// also the flags of the next incoming message before it is read.
|
||||||
func (m *Machine) myMsgFlags() msgFlags {
|
func (m *Machine) myMsgFlags() msgFlags {
|
||||||
idx := m.hs.MessageIndex()
|
idx := m.hs.MessageIndex()
|
||||||
if idx < len(m.msgs) {
|
if idx < len(m.msgs) {
|
||||||
@@ -225,7 +231,18 @@ func (m *Machine) ProcessPacket(out, packet []byte) ([]byte, *Result, error) {
|
|||||||
// noise returns (cs1, cs2) where cs1 is the initiator->responder cipher.
|
// noise returns (cs1, cs2) where cs1 is the initiator->responder cipher.
|
||||||
// For 3-message patterns where a responder finishes by reading the final
|
// For 3-message patterns where a responder finishes by reading the final
|
||||||
// message, this ordering would be wrong; revisit when XX/pqIX lands.
|
// message, this ordering would be wrong; revisit when XX/pqIX lands.
|
||||||
msg, eKey, dKey, err := m.hs.ReadMessage(nil, packet[header.Len:])
|
noiseMsg := packet[header.Len:]
|
||||||
|
if m.myMsgFlags().kemCiphertext {
|
||||||
|
var err error
|
||||||
|
// Installing a psk derived from a forged ciphertext is harmless: ReadMessage
|
||||||
|
// then fails without advancing, and the next packet installs its own.
|
||||||
|
noiseMsg, err = m.kemDecapsulate(noiseMsg)
|
||||||
|
if err != nil {
|
||||||
|
return nil, nil, err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
msg, eKey, dKey, err := m.hs.ReadMessage(nil, noiseMsg)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
// Noise ReadMessage failed. The noise library checkpoints and rolls back
|
// Noise ReadMessage failed. The noise library checkpoints and rolls back
|
||||||
// on failure, so the Machine is still alive. The caller can retry with
|
// on failure, so the Machine is still alive. The caller can retry with
|
||||||
@@ -276,6 +293,8 @@ func (m *Machine) ProcessPacket(out, packet []byte) ([]byte, *Result, error) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (m *Machine) completed(eKey, dKey *noise.CipherState) *Result {
|
func (m *Machine) completed(eKey, dKey *noise.CipherState) *Result {
|
||||||
|
m.kemKey = nil
|
||||||
|
m.kemCiphertext = nil
|
||||||
m.result.EKey = eKey
|
m.result.EKey = eKey
|
||||||
m.result.DKey = dKey
|
m.result.DKey = dKey
|
||||||
m.result.MessageIndex = uint64(m.hs.MessageIndex())
|
m.result.MessageIndex = uint64(m.hs.MessageIndex())
|
||||||
@@ -284,7 +303,7 @@ func (m *Machine) completed(eKey, dKey *noise.CipherState) *Result {
|
|||||||
|
|
||||||
func (m *Machine) processPayload(msg []byte, flags msgFlags) error {
|
func (m *Machine) processPayload(msg []byte, flags msgFlags) error {
|
||||||
if len(msg) == 0 {
|
if len(msg) == 0 {
|
||||||
if flags.expectsPayload || flags.expectsCert {
|
if flags.expectsPayload || flags.expectsCert || flags.kemKey {
|
||||||
m.failed = true
|
m.failed = true
|
||||||
return ErrMissingContent
|
return ErrMissingContent
|
||||||
}
|
}
|
||||||
@@ -310,6 +329,12 @@ func (m *Machine) processPayload(msg []byte, flags msgFlags) error {
|
|||||||
return ErrUnexpectedContent
|
return ErrUnexpectedContent
|
||||||
}
|
}
|
||||||
|
|
||||||
|
hasKEMKey := len(payload.KEMKey) > 0
|
||||||
|
if hasKEMKey != flags.kemKey {
|
||||||
|
m.failed = true
|
||||||
|
return ErrUnexpectedContent
|
||||||
|
}
|
||||||
|
|
||||||
// Process payload
|
// Process payload
|
||||||
if flags.expectsPayload {
|
if flags.expectsPayload {
|
||||||
var remoteIndex uint32
|
var remoteIndex uint32
|
||||||
@@ -336,6 +361,13 @@ func (m *Machine) processPayload(msg []byte, flags msgFlags) error {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if flags.kemKey {
|
||||||
|
if err := m.kemEncapsulate(payload.KEMKey); err != nil {
|
||||||
|
m.failed = true
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -380,11 +412,21 @@ func (m *Machine) validateCert(payload Payload) error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (m *Machine) marshalOutgoing(flags msgFlags) ([]byte, error) {
|
func (m *Machine) marshalOutgoing(flags msgFlags) ([]byte, error) {
|
||||||
if !flags.expectsPayload && !flags.expectsCert {
|
if !flags.expectsPayload && !flags.expectsCert && !flags.kemKey {
|
||||||
return nil, nil
|
return nil, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
var p Payload
|
var p Payload
|
||||||
|
if flags.kemKey {
|
||||||
|
if m.kemKey == nil {
|
||||||
|
dk, err := mlkem.GenerateKey1024()
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("generate ML-KEM key: %w", err)
|
||||||
|
}
|
||||||
|
m.kemKey = dk
|
||||||
|
}
|
||||||
|
p.KEMKey = m.kemKey.EncapsulationKey().Bytes()
|
||||||
|
}
|
||||||
if flags.expectsPayload {
|
if flags.expectsPayload {
|
||||||
if !m.indexAllocated {
|
if !m.indexAllocated {
|
||||||
index, err := m.allocIndex()
|
index, err := m.allocIndex()
|
||||||
@@ -436,6 +478,13 @@ func (m *Machine) buildResponse(out []byte) ([]byte, *noise.CipherState, *noise.
|
|||||||
uint64(m.hs.MessageIndex()+1),
|
uint64(m.hs.MessageIndex()+1),
|
||||||
)
|
)
|
||||||
|
|
||||||
|
if flags.kemCiphertext {
|
||||||
|
if m.kemCiphertext == nil {
|
||||||
|
return nil, nil, nil, errors.New("no ML-KEM ciphertext to send")
|
||||||
|
}
|
||||||
|
out = append(out, m.kemCiphertext...)
|
||||||
|
}
|
||||||
|
|
||||||
// noise.WriteMessage appends the encrypted handshake message to out,
|
// noise.WriteMessage appends the encrypted handshake message to out,
|
||||||
// reusing capacity when present.
|
// reusing capacity when present.
|
||||||
//
|
//
|
||||||
|
|||||||
@@ -11,12 +11,15 @@ import (
|
|||||||
type msgFlags struct {
|
type msgFlags struct {
|
||||||
expectsPayload bool // message carries indexes and time
|
expectsPayload bool // message carries indexes and time
|
||||||
expectsCert bool // message carries the certificate
|
expectsCert bool // message carries the certificate
|
||||||
|
kemKey bool // payload carries an ML-KEM encapsulation key
|
||||||
|
kemCiphertext bool // message is prefixed with the ML-KEM ciphertext for the peer's key
|
||||||
}
|
}
|
||||||
|
|
||||||
// subtypeInfo bundles the noise pattern with the per-message flags for a
|
// subtypeInfo bundles the noise pattern with the per-message flags for a
|
||||||
// given handshake subtype.
|
// given handshake subtype.
|
||||||
type subtypeInfo struct {
|
type subtypeInfo struct {
|
||||||
pattern noise.HandshakePattern
|
pattern noise.HandshakePattern
|
||||||
|
pskPlacement int // noise psk modifier position, 0 means no psk token
|
||||||
msgs []msgFlags
|
msgs []msgFlags
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -32,6 +35,22 @@ var subtypeInfos = map[header.MessageSubType]subtypeInfo{
|
|||||||
},
|
},
|
||||||
},
|
},
|
||||||
|
|
||||||
|
// IX with an ephemeral ML-KEM-1024 exchange:
|
||||||
|
// msg1 (I->R): payload + cert + encapsulation key
|
||||||
|
// msg2 (R->I): ciphertext || noise(payload + cert)
|
||||||
|
// The responder encapsulates after reading msg1 and mixes the shared secret in
|
||||||
|
// through the psk2 token at the end of msg2. The ciphertext travels outside the
|
||||||
|
// noise message because the initiator needs the secret before it can process
|
||||||
|
// that token.
|
||||||
|
header.HandshakeIXPSK2MLKEM1024: {
|
||||||
|
pattern: noise.HandshakeIX,
|
||||||
|
pskPlacement: 2,
|
||||||
|
msgs: []msgFlags{
|
||||||
|
{expectsPayload: true, expectsCert: true, kemKey: true},
|
||||||
|
{expectsPayload: true, expectsCert: true, kemCiphertext: true},
|
||||||
|
},
|
||||||
|
},
|
||||||
|
|
||||||
// XX: 3 messages
|
// XX: 3 messages
|
||||||
// msg1 (I->R): payload only
|
// msg1 (I->R): payload only
|
||||||
// msg2 (R->I): payload + cert
|
// msg2 (R->I): payload + cert
|
||||||
|
|||||||
@@ -20,6 +20,7 @@ type Payload struct {
|
|||||||
ResponderIndex uint32
|
ResponderIndex uint32
|
||||||
Time uint64
|
Time uint64
|
||||||
CertVersion uint32
|
CertVersion uint32
|
||||||
|
KEMKey []byte // ML-KEM encapsulation key, only in subtypes that carry one
|
||||||
}
|
}
|
||||||
|
|
||||||
// Proto field numbers for NebulaHandshakeDetails
|
// Proto field numbers for NebulaHandshakeDetails
|
||||||
@@ -29,6 +30,7 @@ const (
|
|||||||
fieldResponderIndex = 3 // uint32
|
fieldResponderIndex = 3 // uint32
|
||||||
fieldTime = 5 // uint64
|
fieldTime = 5 // uint64
|
||||||
fieldCertVersion = 8 // uint32
|
fieldCertVersion = 8 // uint32
|
||||||
|
fieldKEMKey = 9 // bytes
|
||||||
)
|
)
|
||||||
|
|
||||||
// MarshalPayload encodes a handshake payload in protobuf wire format compatible
|
// MarshalPayload encodes a handshake payload in protobuf wire format compatible
|
||||||
@@ -57,6 +59,10 @@ func MarshalPayload(out []byte, p Payload) []byte {
|
|||||||
details = protowire.AppendTag(details, fieldCertVersion, protowire.VarintType)
|
details = protowire.AppendTag(details, fieldCertVersion, protowire.VarintType)
|
||||||
details = protowire.AppendVarint(details, uint64(p.CertVersion))
|
details = protowire.AppendVarint(details, uint64(p.CertVersion))
|
||||||
}
|
}
|
||||||
|
if len(p.KEMKey) > 0 {
|
||||||
|
details = protowire.AppendTag(details, fieldKEMKey, protowire.BytesType)
|
||||||
|
details = protowire.AppendBytes(details, p.KEMKey)
|
||||||
|
}
|
||||||
|
|
||||||
out = protowire.AppendTag(out, 1, protowire.BytesType)
|
out = protowire.AppendTag(out, 1, protowire.BytesType)
|
||||||
out = protowire.AppendBytes(out, details)
|
out = protowire.AppendBytes(out, details)
|
||||||
@@ -161,6 +167,16 @@ func unmarshalPayloadDetails(p *Payload, b []byte) error {
|
|||||||
}
|
}
|
||||||
p.CertVersion = uint32(v)
|
p.CertVersion = uint32(v)
|
||||||
b = b[n:]
|
b = b[n:]
|
||||||
|
case fieldKEMKey:
|
||||||
|
if typ != protowire.BytesType {
|
||||||
|
return errInvalidHandshakeDetails
|
||||||
|
}
|
||||||
|
v, n := protowire.ConsumeBytes(b)
|
||||||
|
if n < 0 {
|
||||||
|
return errInvalidHandshakeDetails
|
||||||
|
}
|
||||||
|
p.KEMKey = append([]byte(nil), v...)
|
||||||
|
b = b[n:]
|
||||||
default:
|
default:
|
||||||
n := protowire.ConsumeFieldValue(num, typ, b)
|
n := protowire.ConsumeFieldValue(num, typ, b)
|
||||||
if n < 0 {
|
if n < 0 {
|
||||||
|
|||||||
+168
-51
@@ -10,12 +10,15 @@ import (
|
|||||||
"net/netip"
|
"net/netip"
|
||||||
"slices"
|
"slices"
|
||||||
"sync"
|
"sync"
|
||||||
|
"sync/atomic"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/rcrowley/go-metrics"
|
"github.com/rcrowley/go-metrics"
|
||||||
"github.com/slackhq/nebula/cert"
|
"github.com/slackhq/nebula/cert"
|
||||||
"github.com/slackhq/nebula/handshake"
|
"github.com/slackhq/nebula/handshake"
|
||||||
|
"github.com/slackhq/nebula/handshake/fragment"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
|
"github.com/slackhq/nebula/ratelimit"
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -49,12 +52,14 @@ type HandshakeConfig struct {
|
|||||||
tryInterval time.Duration
|
tryInterval time.Duration
|
||||||
retries int64
|
retries int64
|
||||||
triggerBuffer int
|
triggerBuffer int
|
||||||
|
pq pqHandshakeConfig
|
||||||
|
|
||||||
messageMetrics *MessageMetrics
|
messageMetrics *MessageMetrics
|
||||||
}
|
}
|
||||||
|
|
||||||
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
|
||||||
@@ -73,6 +78,18 @@ type HandshakeManager struct {
|
|||||||
|
|
||||||
// can be used to trigger outbound handshake for the given vpnIp
|
// can be used to trigger outbound handshake for the given vpnIp
|
||||||
trigger chan netip.Addr
|
trigger chan netip.Addr
|
||||||
|
|
||||||
|
// pq holds the post-quantum settings, which change on reload.
|
||||||
|
pq atomic.Pointer[pqHandshakeConfig]
|
||||||
|
// pqTable reassembles post-quantum msg1s from senders that have not authenticated yet.
|
||||||
|
pqTable *fragment.Table[pqFragKey, pqFragSource]
|
||||||
|
// pqPeers holds vpn addresses that completed a post-quantum handshake, for sticky mode.
|
||||||
|
pqPeers sync.Map
|
||||||
|
// pqAnswered recognises repeats of post-quantum msg1s already answered.
|
||||||
|
pqAnswered *pqAnswered
|
||||||
|
// pqCookies and pqCookieLimiter serve cookies while pqTable is under load.
|
||||||
|
pqCookies *pqCookies
|
||||||
|
pqCookieLimiter *ratelimit.Limiter
|
||||||
}
|
}
|
||||||
|
|
||||||
type HandshakeHostInfo struct {
|
type HandshakeHostInfo struct {
|
||||||
@@ -88,6 +105,8 @@ type HandshakeHostInfo struct {
|
|||||||
|
|
||||||
hostinfo *HostInfo
|
hostinfo *HostInfo
|
||||||
machine *handshake.Machine // The handshake state machine, set during stage 0 (initiator) or beginHandshake (responder multi-message)
|
machine *handshake.Machine // The handshake state machine, set during stage 0 (initiator) or beginHandshake (responder multi-message)
|
||||||
|
pq *pqAttempt // The initiator's post-quantum attempt, pending alongside the classical one
|
||||||
|
lastPQ bool // Whether the latest attempt was post-quantum
|
||||||
}
|
}
|
||||||
|
|
||||||
func (hh *HandshakeHostInfo) cachePacket(l *slog.Logger, t header.MessageType, st header.MessageSubType, packet []byte, f packetCallback, m *cachedPacketMetrics) {
|
func (hh *HandshakeHostInfo) cachePacket(l *slog.Logger, t header.MessageType, st header.MessageSubType, packet []byte, f packetCallback, m *cachedPacketMetrics) {
|
||||||
@@ -116,7 +135,7 @@ func (hh *HandshakeHostInfo) cachePacket(l *slog.Logger, t header.MessageType, s
|
|||||||
}
|
}
|
||||||
|
|
||||||
func NewHandshakeManager(l *slog.Logger, mainHostMap *HostMap, lightHouse *LightHouse, outside udp.Conn, config HandshakeConfig) *HandshakeManager {
|
func NewHandshakeManager(l *slog.Logger, mainHostMap *HostMap, lightHouse *LightHouse, outside udp.Conn, config HandshakeConfig) *HandshakeManager {
|
||||||
return &HandshakeManager{
|
hm := &HandshakeManager{
|
||||||
vpnIps: map[netip.Addr]*HandshakeHostInfo{},
|
vpnIps: map[netip.Addr]*HandshakeHostInfo{},
|
||||||
indexes: map[uint32]*HandshakeHostInfo{},
|
indexes: map[uint32]*HandshakeHostInfo{},
|
||||||
mainHostMap: mainHostMap,
|
mainHostMap: mainHostMap,
|
||||||
@@ -129,7 +148,16 @@ func NewHandshakeManager(l *slog.Logger, mainHostMap *HostMap, lightHouse *Light
|
|||||||
metricInitiated: metrics.GetOrRegisterCounter("handshake_manager.initiated", nil),
|
metricInitiated: metrics.GetOrRegisterCounter("handshake_manager.initiated", nil),
|
||||||
metricTimedOut: metrics.GetOrRegisterCounter("handshake_manager.timed_out", nil),
|
metricTimedOut: metrics.GetOrRegisterCounter("handshake_manager.timed_out", nil),
|
||||||
l: l,
|
l: l,
|
||||||
|
pqTable: fragment.NewTable[pqFragKey, pqFragSource](pqTableConfig),
|
||||||
|
pqAnswered: newPQAnswered(hsTimeout(config.retries, config.tryInterval)),
|
||||||
}
|
}
|
||||||
|
pq := config.pq
|
||||||
|
hm.pq.Store(&pq)
|
||||||
|
hm.pqCookies = newPQCookies(time.Now())
|
||||||
|
// Cookie replies are tiny, but a flood of spoofed fragments must not turn
|
||||||
|
// into a flood of replies.
|
||||||
|
hm.pqCookieLimiter, _ = ratelimit.New(256, time.Millisecond)
|
||||||
|
return hm
|
||||||
}
|
}
|
||||||
|
|
||||||
func (hm *HandshakeManager) Run(ctx context.Context) {
|
func (hm *HandshakeManager) Run(ctx context.Context) {
|
||||||
@@ -144,6 +172,8 @@ func (hm *HandshakeManager) Run(ctx context.Context) {
|
|||||||
hm.handleOutbound(vpnIP, true)
|
hm.handleOutbound(vpnIP, true)
|
||||||
case now := <-clockSource.C:
|
case now := <-clockSource.C:
|
||||||
hm.NextOutboundHandshakeTimerTick(now)
|
hm.NextOutboundHandshakeTimerTick(now)
|
||||||
|
hm.pqTable.Expire(now)
|
||||||
|
hm.pqAnswered.expire(now)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -153,7 +183,7 @@ func (hm *HandshakeManager) HandleIncoming(via ViaSender, packet []byte, h *head
|
|||||||
// don't yet support) are dropped here rather than silently routed through
|
// don't yet support) are dropped here rather than silently routed through
|
||||||
// the IX path. Add a case when introducing a new pattern.
|
// the IX path. Add a case when introducing a new pattern.
|
||||||
switch h.Subtype {
|
switch h.Subtype {
|
||||||
case header.HandshakeIXPSK0:
|
case header.HandshakeIXPSK0, pqSubtype:
|
||||||
// supported
|
// supported
|
||||||
default:
|
default:
|
||||||
hm.l.Debug("dropping handshake with unsupported subtype",
|
hm.l.Debug("dropping handshake with unsupported subtype",
|
||||||
@@ -169,6 +199,11 @@ func (hm *HandshakeManager) HandleIncoming(via ViaSender, packet []byte, h *head
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if header.IsFragmented(h.Subtype) {
|
||||||
|
hm.handleFragment(via, packet, h)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
// First message of a new handshake. The wire format requires RemoteIndex
|
// First message of a new handshake. The wire format requires RemoteIndex
|
||||||
// to be zero here (the initiator has no responder index to fill in yet),
|
// to be zero here (the initiator has no responder index to fill in yet),
|
||||||
// and generateIndex never allocates 0, so any non-zero RemoteIndex on a
|
// and generateIndex never allocates 0, so any non-zero RemoteIndex on a
|
||||||
@@ -180,7 +215,11 @@ func (hm *HandshakeManager) HandleIncoming(via ViaSender, packet []byte, h *head
|
|||||||
"from", via, "remoteIndex", h.RemoteIndex)
|
"from", via, "remoteIndex", h.RemoteIndex)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
hm.beginHandshake(via, packet, h)
|
if hm.pqConfig().require {
|
||||||
|
hm.l.Debug("dropping classical handshake, post-quantum handshakes are required", "from", via)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hm.beginHandshake(via, packet, h, 0)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -229,6 +268,9 @@ func (hm *HandshakeManager) handleOutbound(vpnIp netip.Addr, lighthouseTriggered
|
|||||||
"style": header.SubTypeName(header.Handshake, hh.machine.Subtype()),
|
"style": header.SubTypeName(header.Handshake, hh.machine.Subtype()),
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
if hh.pq != nil {
|
||||||
|
fields = append(fields, "pqInitiatorIndex", hh.pq.index)
|
||||||
|
}
|
||||||
hh.hostinfo.logger(hm.l).Info("Handshake timed out", fields...)
|
hh.hostinfo.logger(hm.l).Info("Handshake timed out", fields...)
|
||||||
hm.metricTimedOut.Inc(1)
|
hm.metricTimedOut.Inc(1)
|
||||||
hm.DeleteHostInfo(hostinfo)
|
hm.DeleteHostInfo(hostinfo)
|
||||||
@@ -238,14 +280,32 @@ func (hm *HandshakeManager) handleOutbound(vpnIp netip.Addr, lighthouseTriggered
|
|||||||
// Increment the counter to increase our delay, linear backoff
|
// Increment the counter to increase our delay, linear backoff
|
||||||
hh.counter++
|
hh.counter++
|
||||||
|
|
||||||
// Check if we have a handshake packet to transmit yet
|
// Pick this attempt's style and make sure its first message exists. A PQ
|
||||||
|
// attempt sends msg1 as fragments: now goes out immediately, later after the
|
||||||
|
// repair delay, and every attempt offers fresh repair symbols.
|
||||||
|
var now, later [][]byte
|
||||||
|
var machine *handshake.Machine
|
||||||
|
hh.lastPQ = hm.usePQ(hh, vpnIp, lighthouseTriggered)
|
||||||
|
if hh.lastPQ {
|
||||||
|
if hh.pq == nil && !hm.buildPQAttempt(hh) {
|
||||||
|
hm.OutboundHandshakeTimer.Add(vpnIp, hm.config.tryInterval*time.Duration(hh.counter))
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var err error
|
||||||
|
now, later, err = hh.pq.sender.Attempt(fragment.DefaultRepair(hh.pq.sender.Layout().K))
|
||||||
|
if err != nil {
|
||||||
|
hostinfo.logger(hm.l).Error("Failed to fragment handshake", "error", err)
|
||||||
|
hm.OutboundHandshakeTimer.Add(vpnIp, hm.config.tryInterval*time.Duration(hh.counter))
|
||||||
|
return
|
||||||
|
}
|
||||||
|
machine = hh.pq.machine
|
||||||
|
} else {
|
||||||
if !hh.ready {
|
if !hh.ready {
|
||||||
if !hm.buildStage0Packet(hh) {
|
if !hm.buildStage0Packet(hh) {
|
||||||
hm.OutboundHandshakeTimer.Add(vpnIp, hm.config.tryInterval*time.Duration(hh.counter))
|
hm.OutboundHandshakeTimer.Add(vpnIp, hm.config.tryInterval*time.Duration(hh.counter))
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO: this hardcodes "always retransmit stage 0", which is correct for
|
// TODO: this hardcodes "always retransmit stage 0", which is correct for
|
||||||
// IX (the initiator only ever sends one packet, msg1) but wrong the
|
// IX (the initiator only ever sends one packet, msg1) but wrong the
|
||||||
// moment a 3+ message pattern lands. The retry loop should resend the
|
// moment a 3+ message pattern lands. The retry loop should resend the
|
||||||
@@ -253,18 +313,12 @@ func (hm *HandshakeManager) handleOutbound(vpnIp netip.Addr, lighthouseTriggered
|
|||||||
// HandshakeHostInfo tracking a single "currentOutbound" packet (bytes +
|
// HandshakeHostInfo tracking a single "currentOutbound" packet (bytes +
|
||||||
// header metadata) that gets replaced as the handshake progresses,
|
// header metadata) that gets replaced as the handshake progresses,
|
||||||
// instead of indexing into HandshakePacket.
|
// instead of indexing into HandshakePacket.
|
||||||
stage0 := hostinfo.HandshakePacket[handshakePacketStage0]
|
now = [][]byte{hostinfo.HandshakePacket[handshakePacketStage0]}
|
||||||
hsFields := m{
|
machine = hh.machine
|
||||||
"stage": uint64(hh.machine.MessageIndex()),
|
|
||||||
"style": header.SubTypeName(header.Handshake, hh.machine.Subtype()),
|
|
||||||
}
|
}
|
||||||
|
hsFields := m{
|
||||||
// Get a remotes object if we don't already have one.
|
"stage": uint64(machine.MessageIndex()),
|
||||||
// This is mainly to protect us as this should never be the case
|
"style": header.SubTypeName(header.Handshake, machine.Subtype()),
|
||||||
// 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())
|
||||||
@@ -292,8 +346,10 @@ func (hm *HandshakeManager) handleOutbound(vpnIp netip.Addr, lighthouseTriggered
|
|||||||
// Send the handshake to all known ips, stage 2 takes care of assigning the hostinfo.remote based on the first to reply
|
// Send the handshake to all known ips, stage 2 takes care of assigning the hostinfo.remote based on the first to reply
|
||||||
var sentTo []netip.AddrPort
|
var sentTo []netip.AddrPort
|
||||||
hostinfo.remotes.ForEach(hm.mainHostMap.GetPreferredRanges(), func(addr netip.AddrPort, _ bool) {
|
hostinfo.remotes.ForEach(hm.mainHostMap.GetPreferredRanges(), func(addr netip.AddrPort, _ bool) {
|
||||||
hm.messageMetrics.Tx(header.Handshake, hh.machine.Subtype(), 1)
|
hm.messageMetrics.Tx(header.Handshake, machine.Subtype(), int64(len(now)+len(later)))
|
||||||
err := hm.outside.WriteTo(stage0, addr)
|
err := hm.sendFragmented(now, later, func(p []byte) error {
|
||||||
|
return hm.outside.WriteTo(p, addr)
|
||||||
|
})
|
||||||
if err != nil {
|
if err != nil {
|
||||||
// These repeat every attempt, so match the success log below and only shout when the remotes changed
|
// These repeat every attempt, so match the success log below and only shout when the remotes changed
|
||||||
level := slog.LevelDebug
|
level := slog.LevelDebug
|
||||||
@@ -329,7 +385,7 @@ func (hm *HandshakeManager) handleOutbound(vpnIp netip.Addr, lighthouseTriggered
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
hm.f.relayManager.StartRelays(hm.f, vpnIp, hh, stage0)
|
hm.f.relayManager.StartRelays(hm.f, vpnIp, hh, now, later)
|
||||||
|
|
||||||
// If a lighthouse triggered this attempt then we are still in the timer wheel and do not need to re-add
|
// If a lighthouse triggered this attempt then we are still in the timer wheel and do not need to re-add
|
||||||
if !lighthouseTriggered {
|
if !lighthouseTriggered {
|
||||||
@@ -371,6 +427,9 @@ 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{},
|
||||||
@@ -536,6 +595,10 @@ func (hm *HandshakeManager) DeleteHostInfo(hostinfo *HostInfo) {
|
|||||||
func (hm *HandshakeManager) unlockedDeleteHostInfo(hostinfo *HostInfo) {
|
func (hm *HandshakeManager) unlockedDeleteHostInfo(hostinfo *HostInfo) {
|
||||||
for _, addr := range hostinfo.vpnAddrs {
|
for _, addr := range hostinfo.vpnAddrs {
|
||||||
if cur, ok := hm.vpnIps[addr]; ok && cur.hostinfo == hostinfo {
|
if cur, ok := hm.vpnIps[addr]; ok && cur.hostinfo == hostinfo {
|
||||||
|
// A PQ attempt holds its own index alongside the hostinfo's.
|
||||||
|
if idx := cur.pqIndex(); idx != 0 && hm.indexes[idx] == cur {
|
||||||
|
delete(hm.indexes, idx)
|
||||||
|
}
|
||||||
delete(hm.vpnIps, addr)
|
delete(hm.vpnIps, addr)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -646,9 +709,8 @@ func hsTimeout(tries int64, interval time.Duration) time.Duration {
|
|||||||
return time.Duration(tries / 2 * ((2 * int64(interval)) + (tries-1)*int64(interval)))
|
return time.Duration(tries / 2 * ((2 * int64(interval)) + (tries-1)*int64(interval)))
|
||||||
}
|
}
|
||||||
|
|
||||||
// buildStage0Packet creates the initial handshake packet for the initiator.
|
// initiatingVersion picks the certificate version to initiate a handshake with.
|
||||||
func (hm *HandshakeManager) buildStage0Packet(hh *HandshakeHostInfo) bool {
|
func (hm *HandshakeManager) initiatingVersion(hh *HandshakeHostInfo, cs *CertState) cert.Version {
|
||||||
cs := hm.f.pki.getCertState()
|
|
||||||
v := cs.DefaultVersion()
|
v := cs.DefaultVersion()
|
||||||
if hh.initiatingVersionOverride != cert.VersionPre1 {
|
if hh.initiatingVersionOverride != cert.VersionPre1 {
|
||||||
v = hh.initiatingVersionOverride
|
v = hh.initiatingVersionOverride
|
||||||
@@ -660,6 +722,13 @@ func (hm *HandshakeManager) buildStage0Packet(hh *HandshakeHostInfo) bool {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
// buildStage0Packet creates the initial handshake packet for the initiator.
|
||||||
|
func (hm *HandshakeManager) buildStage0Packet(hh *HandshakeHostInfo) bool {
|
||||||
|
cs := hm.f.pki.getCertState()
|
||||||
|
v := hm.initiatingVersion(hh, cs)
|
||||||
|
|
||||||
cred := cs.GetCredential(v)
|
cred := cs.GetCredential(v)
|
||||||
if cred == nil {
|
if cred == nil {
|
||||||
@@ -698,7 +767,10 @@ func (hm *HandshakeManager) buildStage0Packet(hh *HandshakeHostInfo) bool {
|
|||||||
// beginHandshake handles an incoming handshake packet that doesn't match any
|
// beginHandshake handles an incoming handshake packet that doesn't match any
|
||||||
// existing pending handshake. It creates a new responder Machine and processes
|
// existing pending handshake. It creates a new responder Machine and processes
|
||||||
// the first message.
|
// the first message.
|
||||||
func (hm *HandshakeManager) beginHandshake(via ViaSender, packet []byte, h *header.H) {
|
//
|
||||||
|
// received is the number of bytes a fragmented msg1 arrived in, which bounds the
|
||||||
|
// response sent back before the address is validated; 0 for unfragmented ones.
|
||||||
|
func (hm *HandshakeManager) beginHandshake(via ViaSender, packet []byte, h *header.H, received int) {
|
||||||
f := hm.f
|
f := hm.f
|
||||||
cs := f.pki.getCertState()
|
cs := f.pki.getCertState()
|
||||||
|
|
||||||
@@ -712,7 +784,7 @@ func (hm *HandshakeManager) beginHandshake(via ViaSender, packet []byte, h *head
|
|||||||
machine, err := handshake.NewMachine(
|
machine, err := handshake.NewMachine(
|
||||||
v, cs.GetCredential,
|
v, cs.GetCredential,
|
||||||
hm.certVerifier(), func() (uint32, error) { return generateIndex(f.l) },
|
hm.certVerifier(), func() (uint32, error) { return generateIndex(f.l) },
|
||||||
false, header.HandshakeIXPSK0,
|
false, h.Subtype,
|
||||||
)
|
)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
f.l.Error("Failed to create handshake machine", "from", via, "error", err)
|
f.l.Error("Failed to create handshake machine", "from", via, "error", err)
|
||||||
@@ -749,8 +821,14 @@ func (hm *HandshakeManager) beginHandshake(via ViaSender, packet []byte, h *head
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
|
connState, err := newConnectionStateFromResult(result)
|
||||||
|
if err != nil {
|
||||||
|
f.l.Error("Discarding handshake with an invalid message index", "error", err, "vpnAddrs", vpnAddrs)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
hostinfo := &HostInfo{
|
hostinfo := &HostInfo{
|
||||||
ConnectionState: newConnectionStateFromResult(result),
|
ConnectionState: connState,
|
||||||
localIndexId: result.LocalIndex,
|
localIndexId: result.LocalIndex,
|
||||||
remoteIndexId: result.RemoteIndex,
|
remoteIndexId: result.RemoteIndex,
|
||||||
vpnAddrs: vpnAddrs,
|
vpnAddrs: vpnAddrs,
|
||||||
@@ -796,11 +874,15 @@ func (hm *HandshakeManager) beginHandshake(via ViaSender, packet []byte, h *head
|
|||||||
|
|
||||||
existing, err := hm.CheckAndComplete(hostinfo, handshakePacketStage0, f)
|
existing, err := hm.CheckAndComplete(hostinfo, handshakePacketStage0, f)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
hm.handleCheckAndCompleteError(err, existing, hostinfo, via)
|
hm.handleCheckAndCompleteError(err, existing, hostinfo, via, machine.Subtype(), received)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
hm.sendHandshakeResponse(via, response, hostinfo, false)
|
hm.sendHandshakeResponse(via, response, hostinfo, false, received)
|
||||||
|
if header.IsFragmented(machine.Subtype()) {
|
||||||
|
hm.pqAnswered.add(packet[header.Len:], hostinfo, time.Now())
|
||||||
|
}
|
||||||
|
hm.notePQPeer(machine.Subtype(), vpnAddrs)
|
||||||
hostinfo.remotes.RefreshFromHandshake(vpnAddrs)
|
hostinfo.remotes.RefreshFromHandshake(vpnAddrs)
|
||||||
|
|
||||||
// Don't wait for UpdateWorker
|
// Don't wait for UpdateWorker
|
||||||
@@ -811,23 +893,32 @@ func (hm *HandshakeManager) beginHandshake(via ViaSender, packet []byte, h *head
|
|||||||
|
|
||||||
// continueHandshake feeds an incoming packet to an existing pending handshake Machine.
|
// continueHandshake feeds an incoming packet to an existing pending handshake Machine.
|
||||||
func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostInfo, packet []byte) {
|
func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostInfo, packet []byte) {
|
||||||
f := hm.f
|
|
||||||
|
|
||||||
hh.Lock()
|
hh.Lock()
|
||||||
defer hh.Unlock()
|
defer hh.Unlock()
|
||||||
|
|
||||||
// Re-verify hh is still tracked. Between queryIndex returning and us taking
|
if !hm.stillPending(hh, hh.hostinfo.localIndexId) {
|
||||||
// hh.Lock, handleOutbound may have timed out and deleted it. Once we hold
|
|
||||||
// hh.Lock no other deleter can race our index: handleOutbound also takes
|
|
||||||
// hh.Lock first, and handleRecvError targets a main-hostmap entry with a
|
|
||||||
// different localIndexId.
|
|
||||||
hm.RLock()
|
|
||||||
cur, ok := hm.indexes[hh.hostinfo.localIndexId]
|
|
||||||
hm.RUnlock()
|
|
||||||
if !ok || cur != hh {
|
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
hm.processResponse(via, hh, hh.machine, packet)
|
||||||
|
}
|
||||||
|
|
||||||
|
// stillPending re-verifies hh is still tracked under index. Between queryIndex
|
||||||
|
// returning and the caller taking hh.Lock, handleOutbound may have timed out and
|
||||||
|
// deleted it. Once hh.Lock is held no other deleter can race the index:
|
||||||
|
// handleOutbound also takes hh.Lock first, and handleRecvError targets a
|
||||||
|
// main-hostmap entry with a different localIndexId. The caller must hold hh.Lock.
|
||||||
|
func (hm *HandshakeManager) stillPending(hh *HandshakeHostInfo, index uint32) bool {
|
||||||
|
hm.RLock()
|
||||||
|
defer hm.RUnlock()
|
||||||
|
cur, ok := hm.indexes[index]
|
||||||
|
return ok && cur == hh
|
||||||
|
}
|
||||||
|
|
||||||
|
// processResponse runs a responder's message through one of the initiator's
|
||||||
|
// pending attempts and completes the tunnel when the handshake finishes. The
|
||||||
|
// caller must hold hh.Lock.
|
||||||
|
func (hm *HandshakeManager) processResponse(via ViaSender, hh *HandshakeHostInfo, machine *handshake.Machine, packet []byte) {
|
||||||
|
f := hm.f
|
||||||
hostinfo := hh.hostinfo
|
hostinfo := hh.hostinfo
|
||||||
if !via.IsRelayed {
|
if !via.IsRelayed {
|
||||||
if !f.lightHouse.GetRemoteAllowList().AllowAll(hostinfo.vpnAddrs, via.UdpAddr.Addr()) {
|
if !f.lightHouse.GetRemoteAllowList().AllowAll(hostinfo.vpnAddrs, via.UdpAddr.Addr()) {
|
||||||
@@ -837,7 +928,6 @@ func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostIn
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
machine := hh.machine
|
|
||||||
if machine == nil {
|
if machine == nil {
|
||||||
f.l.Error("No handshake machine available for continuation",
|
f.l.Error("No handshake machine available for continuation",
|
||||||
"vpnAddrs", hostinfo.vpnAddrs, "from", via)
|
"vpnAddrs", hostinfo.vpnAddrs, "from", via)
|
||||||
@@ -860,7 +950,7 @@ func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostIn
|
|||||||
}
|
}
|
||||||
|
|
||||||
if response != nil {
|
if response != nil {
|
||||||
hm.sendHandshakeResponse(via, response, hostinfo, false)
|
hm.sendHandshakeResponse(via, response, hostinfo, false, 0)
|
||||||
}
|
}
|
||||||
|
|
||||||
if result == nil {
|
if result == nil {
|
||||||
@@ -868,7 +958,13 @@ func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostIn
|
|||||||
}
|
}
|
||||||
|
|
||||||
// Handshake complete; build the ConnectionState now that we have keys and a verified peer cert.
|
// Handshake complete; build the ConnectionState now that we have keys and a verified peer cert.
|
||||||
hostinfo.ConnectionState = newConnectionStateFromResult(result)
|
cs, err := newConnectionStateFromResult(result)
|
||||||
|
if err != nil {
|
||||||
|
f.l.Error("Discarding handshake with an invalid message index", "error", err, "vpnAddrs", hostinfo.vpnAddrs)
|
||||||
|
hm.DeleteHostInfo(hostinfo)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hostinfo.ConnectionState = cs
|
||||||
|
|
||||||
remoteCert := result.RemoteCert
|
remoteCert := result.RemoteCert
|
||||||
if remoteCert == nil {
|
if remoteCert == nil {
|
||||||
@@ -934,13 +1030,14 @@ 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
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -966,7 +1063,10 @@ func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostIn
|
|||||||
hostinfo.vpnAddrs = vpnAddrs
|
hostinfo.vpnAddrs = vpnAddrs
|
||||||
hostinfo.buildNetworks(f.myVpnNetworksTable, remoteCert.Certificate)
|
hostinfo.buildNetworks(f.myVpnNetworksTable, remoteCert.Certificate)
|
||||||
|
|
||||||
|
// The classical and PQ attempts each hold an index; keep the one that won.
|
||||||
|
hm.settleIndex(hh, result.LocalIndex)
|
||||||
hm.Complete(hostinfo, f)
|
hm.Complete(hostinfo, f)
|
||||||
|
hm.notePQPeer(machine.Subtype(), vpnAddrs)
|
||||||
|
|
||||||
if len(hh.packetStore) > 0 {
|
if len(hh.packetStore) > 0 {
|
||||||
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
if f.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
@@ -975,6 +1075,9 @@ 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)))
|
||||||
@@ -1042,20 +1145,23 @@ func (hm *HandshakeManager) validatePeerCert(via ViaSender, remoteCert *cert.Cac
|
|||||||
// cached is true when msg is a stored response being retransmitted because
|
// cached is true when msg is a stored response being retransmitted because
|
||||||
// the peer's stage-1 retransmit landed (the ErrAlreadySeen path); false on a
|
// the peer's stage-1 retransmit landed (the ErrAlreadySeen path); false on a
|
||||||
// fresh response.
|
// fresh response.
|
||||||
func (hm *HandshakeManager) sendHandshakeResponse(via ViaSender, msg []byte, hostinfo *HostInfo, cached bool) {
|
//
|
||||||
|
// received is the number of bytes a fragmented msg1 arrived in; it bounds what a
|
||||||
|
// fragmented response may send back. It is ignored for unfragmented subtypes.
|
||||||
|
func (hm *HandshakeManager) sendHandshakeResponse(via ViaSender, msg []byte, hostinfo *HostInfo, cached bool, received int) {
|
||||||
if msg == nil {
|
if msg == nil {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
f := hm.f
|
f := hm.f
|
||||||
f.messageMetrics.Tx(header.Handshake, header.MessageSubType(msg[1]), 1)
|
subtype := header.MessageSubType(msg[1])
|
||||||
|
|
||||||
// Common log fields. peerCert may be nil during intermediate
|
// Common log fields. peerCert may be nil during intermediate
|
||||||
// multi-message flows (handshake hasn't completed yet); skip the cert
|
// multi-message flows (handshake hasn't completed yet); skip the cert
|
||||||
// block if so.
|
// block if so.
|
||||||
logFields := []any{
|
logFields := []any{
|
||||||
"vpnAddrs", hostinfo.vpnAddrs,
|
"vpnAddrs", hostinfo.vpnAddrs,
|
||||||
"handshake", m{"stage": uint64(2), "style": header.SubTypeName(header.Handshake, header.HandshakeIXPSK0)},
|
"handshake", m{"stage": uint64(2), "style": header.SubTypeName(header.Handshake, subtype)},
|
||||||
"cached", cached,
|
"cached", cached,
|
||||||
"initiatorIndex", hostinfo.remoteIndexId,
|
"initiatorIndex", hostinfo.remoteIndexId,
|
||||||
"responderIndex", hostinfo.localIndexId,
|
"responderIndex", hostinfo.localIndexId,
|
||||||
@@ -1069,6 +1175,17 @@ func (hm *HandshakeManager) sendHandshakeResponse(via ViaSender, msg []byte, hos
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if header.IsFragmented(subtype) {
|
||||||
|
fields := append(logFields, "from", via)
|
||||||
|
if err := hm.sendFragmentedResponse(via, msg, hostinfo, cached, received); err != nil {
|
||||||
|
f.l.Debug("Did not send handshake message", append(fields, "error", err)...)
|
||||||
|
} else {
|
||||||
|
f.l.Info("Handshake message sent", fields...)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
f.messageMetrics.Tx(header.Handshake, subtype, 1)
|
||||||
if !via.IsRelayed {
|
if !via.IsRelayed {
|
||||||
fields := append(logFields, "from", via)
|
fields := append(logFields, "from", via)
|
||||||
err := f.outside.WriteTo(msg, via.UdpAddr)
|
err := f.outside.WriteTo(msg, via.UdpAddr)
|
||||||
@@ -1086,7 +1203,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)
|
f.SendVia(via.relayHI, via.relay, msg, make([]byte, 12), make([]byte, mtu), false, 0)
|
||||||
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])...)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -1095,10 +1212,10 @@ func (hm *HandshakeManager) sendHandshakeResponse(via ViaSender, msg []byte, hos
|
|||||||
// This only fires from the responder-side beginHandshake path, after the
|
// This only fires from the responder-side beginHandshake path, after the
|
||||||
// peer cert has been validated and ConnectionState populated, so peerCert
|
// peer cert has been validated and ConnectionState populated, so peerCert
|
||||||
// is always non-nil for the cases that log it.
|
// is always non-nil for the cases that log it.
|
||||||
func (hm *HandshakeManager) handleCheckAndCompleteError(err error, existing, hostinfo *HostInfo, via ViaSender) {
|
func (hm *HandshakeManager) handleCheckAndCompleteError(err error, existing, hostinfo *HostInfo, via ViaSender, subtype header.MessageSubType, received int) {
|
||||||
f := hm.f
|
f := hm.f
|
||||||
peerCert := hostinfo.ConnectionState.peerCert
|
peerCert := hostinfo.ConnectionState.peerCert
|
||||||
hsFields := m{"stage": uint64(1), "style": header.SubTypeName(header.Handshake, header.HandshakeIXPSK0)}
|
hsFields := m{"stage": uint64(1), "style": header.SubTypeName(header.Handshake, subtype)}
|
||||||
|
|
||||||
switch err {
|
switch err {
|
||||||
case ErrAlreadySeen:
|
case ErrAlreadySeen:
|
||||||
@@ -1109,7 +1226,7 @@ func (hm *HandshakeManager) handleCheckAndCompleteError(err error, existing, hos
|
|||||||
// ephemeral keys; a freshly-built one would have different keys and break
|
// ephemeral keys; a freshly-built one would have different keys and break
|
||||||
// the tunnel even though both sides "completed" the handshake.
|
// the tunnel even though both sides "completed" the handshake.
|
||||||
if msg := existing.HandshakePacket[handshakePacketStage2]; msg != nil {
|
if msg := existing.HandshakePacket[handshakePacketStage2]; msg != nil {
|
||||||
hm.sendHandshakeResponse(via, msg, existing, true)
|
hm.sendHandshakeResponse(via, msg, existing, true, received)
|
||||||
}
|
}
|
||||||
|
|
||||||
case ErrExistingHostInfo:
|
case ErrExistingHostInfo:
|
||||||
|
|||||||
@@ -0,0 +1,699 @@
|
|||||||
|
package nebula
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"crypto/hmac"
|
||||||
|
"crypto/rand"
|
||||||
|
"crypto/sha256"
|
||||||
|
"encoding/binary"
|
||||||
|
"errors"
|
||||||
|
"log/slog"
|
||||||
|
"net/netip"
|
||||||
|
"sync"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/config"
|
||||||
|
"github.com/slackhq/nebula/handshake"
|
||||||
|
"github.com/slackhq/nebula/handshake/fragment"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
// pqSubtype is the post-quantum handshake this node speaks.
|
||||||
|
pqSubtype = header.HandshakeIXPSK2MLKEM1024
|
||||||
|
|
||||||
|
// DefaultPQRepairDelay is how long repair fragments trail the data fragments.
|
||||||
|
DefaultPQRepairDelay = 10 * time.Millisecond
|
||||||
|
|
||||||
|
// pqAmplification bounds what a responder sends in reply to an unvalidated
|
||||||
|
// address, as a multiple of what it received from it.
|
||||||
|
pqAmplification = 3
|
||||||
|
)
|
||||||
|
|
||||||
|
// pqTableConfig bounds the responder's reassembly of msg1 fragments from senders
|
||||||
|
// that have not authenticated yet.
|
||||||
|
var pqTableConfig = fragment.TableConfig{
|
||||||
|
MaxBytes: 4 << 20,
|
||||||
|
MaxEntries: 1024,
|
||||||
|
MaxPerSource: 4,
|
||||||
|
MaxMsgLen: 16384,
|
||||||
|
TTL: 3 * time.Second,
|
||||||
|
}
|
||||||
|
|
||||||
|
type pqHandshakeConfig struct {
|
||||||
|
initiate bool // start PQ handshakes
|
||||||
|
accept bool // answer PQ handshakes
|
||||||
|
require bool // only PQ handshakes, in either direction
|
||||||
|
sticky bool // never fall back to classical for a peer that completed PQ
|
||||||
|
repairDelay time.Duration // delay between data and repair fragments
|
||||||
|
}
|
||||||
|
|
||||||
|
func pqHandshakeConfigFrom(c *config.C) pqHandshakeConfig {
|
||||||
|
cfg := pqHandshakeConfig{
|
||||||
|
initiate: c.GetBool("handshakes.pq.initiate", false),
|
||||||
|
accept: c.GetBool("handshakes.pq.accept", false),
|
||||||
|
require: c.GetBool("handshakes.pq.require", false),
|
||||||
|
sticky: c.GetBool("handshakes.pq.sticky", false),
|
||||||
|
repairDelay: c.GetDuration("handshakes.pq.repair_delay", DefaultPQRepairDelay),
|
||||||
|
}
|
||||||
|
if cfg.require {
|
||||||
|
cfg.initiate = true
|
||||||
|
cfg.accept = true
|
||||||
|
}
|
||||||
|
return cfg
|
||||||
|
}
|
||||||
|
|
||||||
|
// pqConfig returns the post-quantum settings in effect.
|
||||||
|
func (hm *HandshakeManager) pqConfig() *pqHandshakeConfig {
|
||||||
|
return hm.pq.Load()
|
||||||
|
}
|
||||||
|
|
||||||
|
// reloadPQ applies changed post-quantum settings. Handshakes already in flight
|
||||||
|
// keep going; the new settings apply to the next attempt and packet.
|
||||||
|
func (hm *HandshakeManager) reloadPQ(c *config.C) {
|
||||||
|
if !c.HasChanged("handshakes.pq") {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
old := hm.pqConfig()
|
||||||
|
cfg := pqHandshakeConfigFrom(c)
|
||||||
|
hm.pq.Store(&cfg)
|
||||||
|
hm.l.Info("Post-quantum handshake settings changed",
|
||||||
|
"initiate", cfg.initiate, "oldInitiate", old.initiate,
|
||||||
|
"accept", cfg.accept, "oldAccept", old.accept,
|
||||||
|
"require", cfg.require, "oldRequire", old.require,
|
||||||
|
"sticky", cfg.sticky, "oldSticky", old.sticky,
|
||||||
|
"repairDelay", cfg.repairDelay, "oldRepairDelay", old.repairDelay,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
// pqAttempt is the initiator's post-quantum attempt for a pending handshake. It
|
||||||
|
// lives alongside the classical attempt in HandshakeHostInfo and has its own
|
||||||
|
// local index, so whichever answer arrives first wins.
|
||||||
|
type pqAttempt struct {
|
||||||
|
machine *handshake.Machine
|
||||||
|
index uint32
|
||||||
|
sender *fragment.Sender
|
||||||
|
msg2 *fragment.Assembly
|
||||||
|
cookieResendAt time.Time // last resend prompted by a cookie reply
|
||||||
|
heard bool // a msg2 fragment or cookie reply arrived, so the peer speaks PQ
|
||||||
|
}
|
||||||
|
|
||||||
|
// pqFragKey identifies one msg1 being reassembled.
|
||||||
|
type pqFragKey struct {
|
||||||
|
addr netip.AddrPort
|
||||||
|
relay uint32
|
||||||
|
fragID uint32
|
||||||
|
}
|
||||||
|
|
||||||
|
// pqFragSource groups msg1 reassemblies for the per-source quota: an IPv4 /32,
|
||||||
|
// an IPv6 /64, or one relay channel.
|
||||||
|
type pqFragSource struct {
|
||||||
|
prefix netip.Prefix
|
||||||
|
relay uint32
|
||||||
|
}
|
||||||
|
|
||||||
|
func pqFragKeyFor(via ViaSender, fragID uint32) (pqFragKey, pqFragSource) {
|
||||||
|
if via.IsRelayed {
|
||||||
|
return pqFragKey{relay: via.relay.LocalIndex, fragID: fragID},
|
||||||
|
pqFragSource{relay: via.relay.LocalIndex}
|
||||||
|
}
|
||||||
|
addr := via.UdpAddr.Addr().Unmap()
|
||||||
|
bits := 64
|
||||||
|
if addr.Is4() {
|
||||||
|
bits = 32
|
||||||
|
}
|
||||||
|
prefix, _ := addr.Prefix(bits)
|
||||||
|
return pqFragKey{addr: via.UdpAddr, fragID: fragID}, pqFragSource{prefix: prefix}
|
||||||
|
}
|
||||||
|
|
||||||
|
// reassembled rebuilds the packet the handshake Machine expects from the header
|
||||||
|
// of a fragment and the decoded message.
|
||||||
|
func reassembled(h *header.H, msg []byte) []byte {
|
||||||
|
p := make([]byte, header.Len, header.Len+len(msg))
|
||||||
|
header.Encode(p, header.Version, header.Handshake, h.Subtype, h.RemoteIndex, h.MessageCounter)
|
||||||
|
return append(p, msg...)
|
||||||
|
}
|
||||||
|
|
||||||
|
// usePQ decides whether this outbound attempt is post-quantum. A peer that does
|
||||||
|
// not speak PQ silently drops it, so timer retries alternate between PQ and
|
||||||
|
// classical, starting with PQ. An attempt triggered early by a lighthouse reply
|
||||||
|
// is sending to addresses nothing has been sent to yet, and a new path gets the
|
||||||
|
// PQ attempt first. With require, or for a peer that completed a PQ handshake
|
||||||
|
// when sticky is on, every attempt is PQ. Once anything has come back for the PQ
|
||||||
|
// attempt the peer evidently speaks PQ, and a classical attempt would only race
|
||||||
|
// it, so classical stops getting turns.
|
||||||
|
func (hm *HandshakeManager) usePQ(hh *HandshakeHostInfo, vpnIp netip.Addr, triggered bool) bool {
|
||||||
|
cfg := hm.pqConfig()
|
||||||
|
switch {
|
||||||
|
case !cfg.initiate:
|
||||||
|
return false
|
||||||
|
case cfg.require:
|
||||||
|
return true
|
||||||
|
case hh.pq != nil && hh.pq.heard:
|
||||||
|
return true
|
||||||
|
case cfg.sticky:
|
||||||
|
if _, ok := hm.pqPeers.Load(vpnIp); ok {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return hh.counter <= 1 || triggered || !hh.lastPQ
|
||||||
|
}
|
||||||
|
|
||||||
|
// relayEstablished pushes the pending handshake with target through a relay that
|
||||||
|
// just came up, rather than leaving it for the next retry. Nothing has gone over
|
||||||
|
// the relay yet, so like any new path it gets the PQ attempt first, which then
|
||||||
|
// counts as the PQ turn: the next retry is classical, as if it had been sent on
|
||||||
|
// schedule. Without this, relays coming up while the first attempt is in flight
|
||||||
|
// handed every relayed handshake to the classical retry.
|
||||||
|
func (hm *HandshakeManager) relayEstablished(target netip.Addr, relayHI *HostInfo, relay *Relay) {
|
||||||
|
hh := hm.queryVpnIp(target)
|
||||||
|
if hh == nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hh.Lock()
|
||||||
|
defer hh.Unlock()
|
||||||
|
if hm.queryVpnIp(target) != hh {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
var now, later [][]byte
|
||||||
|
switch {
|
||||||
|
case hh.pq != nil:
|
||||||
|
var err error
|
||||||
|
now, later, err = hh.pq.sender.Attempt(fragment.DefaultRepair(hh.pq.sender.Layout().K))
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hh.lastPQ = true
|
||||||
|
case hh.ready:
|
||||||
|
now = [][]byte{hh.hostinfo.HandshakePacket[handshakePacketStage0]}
|
||||||
|
default:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
f := hm.f
|
||||||
|
hh.hostinfo.logger(hm.l).Info("Send handshake via new relay", "relay", relayHI.vpnAddrs[0])
|
||||||
|
_ = hm.sendFragmented(now, later, func(p []byte) error {
|
||||||
|
f.SendVia(relayHI, relay, p, make([]byte, 12), make([]byte, mtu), false, 0)
|
||||||
|
return nil
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// buildPQAttempt creates the initiator's PQ Machine and msg1 sender.
|
||||||
|
func (hm *HandshakeManager) buildPQAttempt(hh *HandshakeHostInfo) bool {
|
||||||
|
cs := hm.f.pki.getCertState()
|
||||||
|
v := hm.initiatingVersion(hh, cs)
|
||||||
|
if cs.GetCredential(v) == nil {
|
||||||
|
hm.f.l.Error("Unable to handshake with host because no certificate is available",
|
||||||
|
"vpnAddrs", hh.hostinfo.vpnAddrs, "certVersion", v)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
pq := &pqAttempt{}
|
||||||
|
machine, err := handshake.NewMachine(
|
||||||
|
v, cs.GetCredential,
|
||||||
|
hm.certVerifier(), func() (uint32, error) { return hm.allocatePQIndex(hh, pq) },
|
||||||
|
true, pqSubtype,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
hm.f.l.Error("Failed to create handshake machine",
|
||||||
|
"vpnAddrs", hh.hostinfo.vpnAddrs, "error", err)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
msg, err := machine.Initiate(nil)
|
||||||
|
if err != nil {
|
||||||
|
hm.f.l.Error("Failed to initiate handshake",
|
||||||
|
"vpnAddrs", hh.hostinfo.vpnAddrs, "error", err)
|
||||||
|
hm.releasePQIndex(hh, pq)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
sender, err := fragment.NewSender(msg[header.Len:], pqSubtype, 0, 1, pq.index)
|
||||||
|
if err != nil {
|
||||||
|
hm.f.l.Error("Failed to fragment handshake",
|
||||||
|
"vpnAddrs", hh.hostinfo.vpnAddrs, "error", err)
|
||||||
|
hm.releasePQIndex(hh, pq)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
pq.machine = machine
|
||||||
|
pq.sender = sender
|
||||||
|
hh.pq = pq
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
// allocatePQIndex registers a local index for the PQ attempt. Unlike
|
||||||
|
// allocateIndex it leaves hostinfo.localIndexId alone; that is settled when one
|
||||||
|
// of the attempts completes.
|
||||||
|
func (hm *HandshakeManager) allocatePQIndex(hh *HandshakeHostInfo, pq *pqAttempt) (uint32, error) {
|
||||||
|
hm.mainHostMap.RLock()
|
||||||
|
defer hm.mainHostMap.RUnlock()
|
||||||
|
hm.Lock()
|
||||||
|
defer hm.Unlock()
|
||||||
|
|
||||||
|
for range 32 {
|
||||||
|
index, err := generateIndex(hm.l)
|
||||||
|
if err != nil {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
|
||||||
|
_, inPending := hm.indexes[index]
|
||||||
|
_, inMain := hm.mainHostMap.Indexes[index]
|
||||||
|
|
||||||
|
if !inMain && !inPending {
|
||||||
|
pq.index = index
|
||||||
|
hm.indexes[index] = hh
|
||||||
|
return index, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0, errors.New("failed to generate unique localIndexId")
|
||||||
|
}
|
||||||
|
|
||||||
|
func (hm *HandshakeManager) releasePQIndex(hh *HandshakeHostInfo, pq *pqAttempt) {
|
||||||
|
hm.Lock()
|
||||||
|
defer hm.Unlock()
|
||||||
|
if pq.index != 0 && hm.indexes[pq.index] == hh {
|
||||||
|
delete(hm.indexes, pq.index)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// settleIndex makes winner the hostinfo's local index and releases the index of
|
||||||
|
// the attempt that lost.
|
||||||
|
func (hm *HandshakeManager) settleIndex(hh *HandshakeHostInfo, winner uint32) {
|
||||||
|
hm.Lock()
|
||||||
|
defer hm.Unlock()
|
||||||
|
for _, idx := range []uint32{hh.hostinfo.localIndexId, hh.pqIndex()} {
|
||||||
|
if idx != 0 && idx != winner && hm.indexes[idx] == hh {
|
||||||
|
delete(hm.indexes, idx)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
hh.hostinfo.localIndexId = winner
|
||||||
|
}
|
||||||
|
|
||||||
|
func (hh *HandshakeHostInfo) pqIndex() uint32 {
|
||||||
|
if hh.pq == nil {
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
return hh.pq.index
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleFragment routes one fragment of a PQ handshake message.
|
||||||
|
func (hm *HandshakeManager) handleFragment(via ViaSender, packet []byte, h *header.H) {
|
||||||
|
if h.MessageCounter == pqCookieCounter {
|
||||||
|
hm.handleCookie(via, packet, h)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
fh, sym, err := fragment.Parse(packet[header.Len:])
|
||||||
|
if err != nil {
|
||||||
|
hm.l.Debug("dropping malformed handshake fragment", "from", via, "error", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
switch h.MessageCounter {
|
||||||
|
case 1:
|
||||||
|
if !hm.pqConfig().accept {
|
||||||
|
hm.l.Debug("dropping post-quantum handshake, not accepting them", "from", via)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if h.RemoteIndex != 0 {
|
||||||
|
hm.l.Debug("dropping stage-1 handshake with non-zero RemoteIndex",
|
||||||
|
"from", via, "remoteIndex", h.RemoteIndex)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
now := time.Now()
|
||||||
|
key, src := pqFragKeyFor(via, fh.FragID)
|
||||||
|
if hm.pqTable.Load() >= pqCookieLoad && !(fh.HasCookie() && hm.pqCookies.valid(key, fh.Cookie, now)) {
|
||||||
|
hm.sendCookie(via, fh, key, len(packet), now)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
res, err := hm.pqTable.Add(key, src, now, fh, sym)
|
||||||
|
if err != nil {
|
||||||
|
hm.l.Debug("dropping handshake fragment", "from", via, "error", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if res == nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if existing := hm.pqAnswered.lookup(res.Msg, time.Now()); existing != nil {
|
||||||
|
// Already answered: resend, rate limited, with fresh symbols.
|
||||||
|
if msg := existing.HandshakePacket[handshakePacketStage2]; msg != nil {
|
||||||
|
hm.sendHandshakeResponse(via, msg, existing, true, res.Received)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hm.beginHandshake(via, reassembled(h, res.Msg), h, res.Received)
|
||||||
|
|
||||||
|
case 2:
|
||||||
|
if hh := hm.queryIndex(h.RemoteIndex); hh != nil {
|
||||||
|
hm.continuePQ(via, hh, h, fh, sym)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// continuePQ collects msg2 fragments for the initiator's PQ attempt.
|
||||||
|
func (hm *HandshakeManager) continuePQ(via ViaSender, hh *HandshakeHostInfo, h *header.H, fh fragment.Header, sym []byte) {
|
||||||
|
hh.Lock()
|
||||||
|
defer hh.Unlock()
|
||||||
|
|
||||||
|
pq := hh.pq
|
||||||
|
if pq == nil || pq.index != h.RemoteIndex || !hm.stillPending(hh, pq.index) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
pq.heard = true
|
||||||
|
|
||||||
|
if pq.msg2 == nil {
|
||||||
|
a, err := fragment.NewAssembly(fh)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
pq.msg2 = a
|
||||||
|
}
|
||||||
|
ready, err := pq.msg2.Add(fh, sym)
|
||||||
|
if errors.Is(err, fragment.ErrMismatch) {
|
||||||
|
// The responder's FragID and MsgLen never change, so this is a stray or a
|
||||||
|
// forgery. Start over from this fragment rather than wedge.
|
||||||
|
pq.msg2 = nil
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if err != nil || !ready {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
msg, err := pq.msg2.Decode()
|
||||||
|
pq.msg2 = nil
|
||||||
|
if err != nil {
|
||||||
|
hm.l.Debug("failed to decode handshake fragments", "from", via, "error", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hm.processResponse(via, hh, pq.machine, reassembled(h, msg))
|
||||||
|
}
|
||||||
|
|
||||||
|
// sendFragmented sends packets to a peer: now immediately and later after the
|
||||||
|
// repair delay. It returns the first error from the immediate sends; errors from
|
||||||
|
// delayed sends are only logged.
|
||||||
|
func (hm *HandshakeManager) sendFragmented(now, later [][]byte, send func([]byte) error) error {
|
||||||
|
var first error
|
||||||
|
for _, p := range now {
|
||||||
|
if err := send(p); err != nil && first == nil {
|
||||||
|
first = err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
sendLater := func() {
|
||||||
|
for _, p := range later {
|
||||||
|
if err := send(p); err != nil {
|
||||||
|
hm.l.Debug("Failed to send handshake repair fragment", "error", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
delay := hm.pqConfig().repairDelay
|
||||||
|
switch {
|
||||||
|
case len(later) == 0:
|
||||||
|
case delay <= 0:
|
||||||
|
sendLater()
|
||||||
|
default:
|
||||||
|
time.AfterFunc(delay, sendLater)
|
||||||
|
}
|
||||||
|
return first
|
||||||
|
}
|
||||||
|
|
||||||
|
// sendFragmentedResponse sends the responder's msg2 as fragments. A resend of a
|
||||||
|
// cached response (cached) offers fresh symbols and is rate limited to one per
|
||||||
|
// retry interval. received is how many bytes the triggering msg1 took, which
|
||||||
|
// bounds what may be sent back before the address is validated.
|
||||||
|
func (hm *HandshakeManager) sendFragmentedResponse(via ViaSender, msg []byte, hostinfo *HostInfo, cached bool, received int) error {
|
||||||
|
now := time.Now()
|
||||||
|
if cached {
|
||||||
|
last := hostinfo.handshakeResendAt.Load()
|
||||||
|
if now.UnixNano()-last < int64(hm.config.tryInterval) ||
|
||||||
|
!hostinfo.handshakeResendAt.CompareAndSwap(last, now.UnixNano()) {
|
||||||
|
return errors.New("handshake response resend rate limited")
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
hostinfo.handshakeResendAt.Store(now.UnixNano())
|
||||||
|
}
|
||||||
|
|
||||||
|
var h header.H
|
||||||
|
if err := h.Parse(msg); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
s, err := fragment.NewSender(msg[header.Len:], h.Subtype, h.RemoteIndex, h.MessageCounter, hostinfo.localIndexId)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
l := s.Layout()
|
||||||
|
repair := fragment.DefaultRepair(l.K)
|
||||||
|
if received > 0 {
|
||||||
|
pktLen := header.Len + fragment.HeaderLen + l.SymbolSize
|
||||||
|
budget := pqAmplification * received / pktLen
|
||||||
|
if budget < l.K {
|
||||||
|
return errors.New("handshake response exceeds the amplification budget")
|
||||||
|
}
|
||||||
|
repair = min(repair, budget-l.K)
|
||||||
|
}
|
||||||
|
|
||||||
|
n := uint32(l.K + repair)
|
||||||
|
s.SetNext(int(hostinfo.handshakeNextSymbol.Add(n) - n))
|
||||||
|
pkts, later, err := s.Attempt(repair)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
if via.IsRelayed {
|
||||||
|
if via.relay == nil {
|
||||||
|
return errors.New("both addr and via.relay are nil")
|
||||||
|
}
|
||||||
|
// We received a valid handshake on this relay, so make sure the relay
|
||||||
|
// state reflects that, in case it had been marked Disestablished.
|
||||||
|
hostinfo.relayState.InsertRelayTo(via.relayHI.vpnAddrs[0])
|
||||||
|
via.relayHI.relayState.UpdateRelayForByIdxState(via.relay.LocalIndex, Established)
|
||||||
|
}
|
||||||
|
hm.f.messageMetrics.Tx(header.Handshake, h.Subtype, int64(len(pkts)+len(later)))
|
||||||
|
return hm.sendFragmented(pkts, later, hm.sendTo(via))
|
||||||
|
}
|
||||||
|
|
||||||
|
// notePQPeer remembers peers that completed a PQ handshake, for sticky mode.
|
||||||
|
func (hm *HandshakeManager) notePQPeer(subtype header.MessageSubType, vpnAddrs []netip.Addr) {
|
||||||
|
if !hm.pqConfig().sticky || subtype != pqSubtype {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
for _, a := range vpnAddrs {
|
||||||
|
hm.pqPeers.Store(a, struct{}{})
|
||||||
|
}
|
||||||
|
if hm.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
|
hm.l.Debug("Remembering post-quantum peer", "vpnAddrs", vpnAddrs)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// pqAnswered remembers the msg1s a responder recently answered, keyed by hash,
|
||||||
|
// so a repeat is recognised before any noise, KEM or certificate work. Repeats
|
||||||
|
// are routine: the trailing repair fragments of an attempt rebuild a msg1 that
|
||||||
|
// its data fragments already completed, and a retrying initiator offers fresh
|
||||||
|
// symbols for the same msg1. Entries only exist for completed handshakes, which
|
||||||
|
// need a valid certificate, and live as long as an initiator keeps retrying.
|
||||||
|
type pqAnswered struct {
|
||||||
|
sync.Mutex
|
||||||
|
ttl time.Duration
|
||||||
|
entries map[[sha256.Size]byte]pqAnsweredEntry
|
||||||
|
}
|
||||||
|
|
||||||
|
type pqAnsweredEntry struct {
|
||||||
|
hostinfo *HostInfo
|
||||||
|
at time.Time
|
||||||
|
}
|
||||||
|
|
||||||
|
const pqAnsweredMax = 4096
|
||||||
|
|
||||||
|
func newPQAnswered(ttl time.Duration) *pqAnswered {
|
||||||
|
return &pqAnswered{ttl: ttl, entries: map[[sha256.Size]byte]pqAnsweredEntry{}}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (a *pqAnswered) add(msg1 []byte, hostinfo *HostInfo, now time.Time) {
|
||||||
|
a.Lock()
|
||||||
|
defer a.Unlock()
|
||||||
|
if len(a.entries) >= pqAnsweredMax {
|
||||||
|
for k := range a.entries {
|
||||||
|
delete(a.entries, k)
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
a.entries[sha256.Sum256(msg1)] = pqAnsweredEntry{hostinfo: hostinfo, at: now}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (a *pqAnswered) lookup(msg1 []byte, now time.Time) *HostInfo {
|
||||||
|
a.Lock()
|
||||||
|
defer a.Unlock()
|
||||||
|
e, ok := a.entries[sha256.Sum256(msg1)]
|
||||||
|
if !ok || now.Sub(e.at) > a.ttl {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
return e.hostinfo
|
||||||
|
}
|
||||||
|
|
||||||
|
func (a *pqAnswered) expire(now time.Time) {
|
||||||
|
a.Lock()
|
||||||
|
defer a.Unlock()
|
||||||
|
for k, e := range a.entries {
|
||||||
|
if now.Sub(e.at) > a.ttl {
|
||||||
|
delete(a.entries, k)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// A responder whose msg1 table is under load stops keeping state for senders
|
||||||
|
// that have not shown they receive at their address. It answers a fragment
|
||||||
|
// without a valid cookie with a cookie reply and keeps nothing; the initiator
|
||||||
|
// resends with the cookie attached. This is WireGuard's under-load cookie, QUIC's
|
||||||
|
// Retry and SCTP's state cookie: one extra round trip, only while under attack.
|
||||||
|
const (
|
||||||
|
// pqCookieLoad is the table load above which msg1 fragments need a cookie.
|
||||||
|
pqCookieLoad = 0.5
|
||||||
|
|
||||||
|
// pqCookieCounter marks a cookie reply in the header's message counter.
|
||||||
|
// Handshake messages count from 1.
|
||||||
|
pqCookieCounter = 0
|
||||||
|
|
||||||
|
// pqCookieRotate is how often the cookie secret changes. A cookie stays
|
||||||
|
// valid for between one and two rotations.
|
||||||
|
pqCookieRotate = 2 * time.Minute
|
||||||
|
|
||||||
|
pqCookieReplyLen = header.Len + fragment.CookieLen
|
||||||
|
)
|
||||||
|
|
||||||
|
// pqCookies mints and checks cookies: an HMAC over the sender's address (or relay
|
||||||
|
// channel) and FragID under a rotating secret, with the previous secret still
|
||||||
|
// accepted.
|
||||||
|
type pqCookies struct {
|
||||||
|
sync.Mutex
|
||||||
|
secrets [2][32]byte
|
||||||
|
rotatedAt time.Time
|
||||||
|
}
|
||||||
|
|
||||||
|
func newPQCookies(now time.Time) *pqCookies {
|
||||||
|
c := &pqCookies{rotatedAt: now}
|
||||||
|
_, _ = rand.Read(c.secrets[0][:])
|
||||||
|
_, _ = rand.Read(c.secrets[1][:])
|
||||||
|
return c
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *pqCookies) rotate(now time.Time) {
|
||||||
|
if now.Sub(c.rotatedAt) < pqCookieRotate {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
c.secrets[1] = c.secrets[0]
|
||||||
|
_, _ = rand.Read(c.secrets[0][:])
|
||||||
|
c.rotatedAt = now
|
||||||
|
}
|
||||||
|
|
||||||
|
func cookieMAC(secret []byte, key pqFragKey) fragment.Cookie {
|
||||||
|
mac := hmac.New(sha256.New, secret)
|
||||||
|
addr := key.addr.Addr().As16()
|
||||||
|
mac.Write(addr[:])
|
||||||
|
var b [10]byte
|
||||||
|
binary.BigEndian.PutUint16(b[0:], key.addr.Port())
|
||||||
|
binary.BigEndian.PutUint32(b[2:], key.relay)
|
||||||
|
binary.BigEndian.PutUint32(b[6:], key.fragID)
|
||||||
|
mac.Write(b[:])
|
||||||
|
var c fragment.Cookie
|
||||||
|
copy(c[:], mac.Sum(nil))
|
||||||
|
return c
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *pqCookies) make(key pqFragKey, now time.Time) fragment.Cookie {
|
||||||
|
c.Lock()
|
||||||
|
defer c.Unlock()
|
||||||
|
c.rotate(now)
|
||||||
|
return cookieMAC(c.secrets[0][:], key)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *pqCookies) valid(key pqFragKey, cookie fragment.Cookie, now time.Time) bool {
|
||||||
|
c.Lock()
|
||||||
|
defer c.Unlock()
|
||||||
|
c.rotate(now)
|
||||||
|
for _, s := range c.secrets {
|
||||||
|
want := cookieMAC(s[:], key)
|
||||||
|
if hmac.Equal(want[:], cookie[:]) {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// sendCookie answers a msg1 fragment that arrived without a valid cookie while
|
||||||
|
// under load. The reply is never larger than what triggered it, and replies are
|
||||||
|
// rate limited as a whole.
|
||||||
|
func (hm *HandshakeManager) sendCookie(via ViaSender, fh fragment.Header, key pqFragKey, received int, now time.Time) {
|
||||||
|
if received < pqCookieReplyLen {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if _, ok := hm.pqCookieLimiter.Allow(); !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
c := hm.pqCookies.make(key, now)
|
||||||
|
reply := make([]byte, header.Len, pqCookieReplyLen)
|
||||||
|
header.Encode(reply, header.Version, header.Handshake, pqSubtype, fh.FragID, pqCookieCounter)
|
||||||
|
reply = append(reply, c[:]...)
|
||||||
|
hm.f.messageMetrics.Tx(header.Handshake, pqSubtype, 1)
|
||||||
|
if err := hm.sendTo(via)(reply); err != nil {
|
||||||
|
hm.l.Debug("Failed to send handshake cookie", "to", via, "error", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleCookie attaches a responder's cookie to the PQ attempt it names and
|
||||||
|
// resends right away, at most once per retry interval, rather than waiting for
|
||||||
|
// the next attempt.
|
||||||
|
func (hm *HandshakeManager) handleCookie(via ViaSender, packet []byte, h *header.H) {
|
||||||
|
if len(packet) != pqCookieReplyLen {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hh := hm.queryIndex(h.RemoteIndex)
|
||||||
|
if hh == nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hh.Lock()
|
||||||
|
defer hh.Unlock()
|
||||||
|
|
||||||
|
pq := hh.pq
|
||||||
|
if pq == nil || pq.index != h.RemoteIndex || !hm.stillPending(hh, pq.index) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var c fragment.Cookie
|
||||||
|
copy(c[:], packet[header.Len:])
|
||||||
|
pq.sender.SetCookie(c)
|
||||||
|
pq.heard = true
|
||||||
|
|
||||||
|
now := time.Now()
|
||||||
|
if now.Sub(pq.cookieResendAt) < hm.config.tryInterval {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
pq.cookieResendAt = now
|
||||||
|
pkts, later, err := pq.sender.Attempt(fragment.DefaultRepair(pq.sender.Layout().K))
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
hm.messageMetrics.Tx(header.Handshake, pqSubtype, int64(len(pkts)+len(later)))
|
||||||
|
if err := hm.sendFragmented(pkts, later, hm.sendTo(via)); err != nil {
|
||||||
|
hm.l.Debug("Failed to resend handshake with cookie", "to", via, "error", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// sendTo returns a function sending a packet back the way via came: directly, or
|
||||||
|
// through the relay it arrived on.
|
||||||
|
func (hm *HandshakeManager) sendTo(via ViaSender) func([]byte) error {
|
||||||
|
f := hm.f
|
||||||
|
if !via.IsRelayed {
|
||||||
|
return func(p []byte) error {
|
||||||
|
return f.outside.WriteTo(p, via.UdpAddr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return func(p []byte) error {
|
||||||
|
if via.relay == nil {
|
||||||
|
return errors.New("both addr and via.relay are nil")
|
||||||
|
}
|
||||||
|
f.SendVia(via.relayHI, via.relay, p, make([]byte, 12), make([]byte, mtu), false, 0)
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,398 @@
|
|||||||
|
package nebula
|
||||||
|
|
||||||
|
import (
|
||||||
|
"math/rand/v2"
|
||||||
|
"net/netip"
|
||||||
|
"sync"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/slackhq/nebula/config"
|
||||||
|
"github.com/slackhq/nebula/handshake/fragment"
|
||||||
|
"github.com/slackhq/nebula/header"
|
||||||
|
"github.com/slackhq/nebula/test"
|
||||||
|
"github.com/slackhq/nebula/udp"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
)
|
||||||
|
|
||||||
|
// recordingConn captures what is written to it.
|
||||||
|
type recordingConn struct {
|
||||||
|
udp.NoopConn
|
||||||
|
sync.Mutex
|
||||||
|
sent [][]byte
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *recordingConn) WriteTo(b []byte, _ netip.AddrPort) error {
|
||||||
|
c.Lock()
|
||||||
|
defer c.Unlock()
|
||||||
|
c.sent = append(c.sent, append([]byte(nil), b...))
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *recordingConn) take() [][]byte {
|
||||||
|
c.Lock()
|
||||||
|
defer c.Unlock()
|
||||||
|
s := c.sent
|
||||||
|
c.sent = nil
|
||||||
|
return s
|
||||||
|
}
|
||||||
|
|
||||||
|
func newPQTestManager(t *testing.T) (*HandshakeManager, *recordingConn) {
|
||||||
|
l := test.NewLogger()
|
||||||
|
conn := &recordingConn{}
|
||||||
|
cfg := defaultHandshakeConfig
|
||||||
|
cfg.pq = pqHandshakeConfig{initiate: true, accept: true}
|
||||||
|
hm := NewHandshakeManager(l, newHostMap(l), newTestLighthouse(), conn, cfg)
|
||||||
|
hm.f = &Interface{
|
||||||
|
handshakeManager: hm,
|
||||||
|
outside: conn,
|
||||||
|
messageMetrics: newMessageMetricsOnlyRecvError(),
|
||||||
|
l: l,
|
||||||
|
}
|
||||||
|
return hm, conn
|
||||||
|
}
|
||||||
|
|
||||||
|
// fragmentIndexes checks every packet is a fragment of the expected response and
|
||||||
|
// returns their symbol indexes.
|
||||||
|
func fragmentIndexes(t *testing.T, pkts [][]byte, fragID, remoteIndex uint32) []int {
|
||||||
|
t.Helper()
|
||||||
|
var out []int
|
||||||
|
for _, p := range pkts {
|
||||||
|
require.LessOrEqual(t, len(p), fragment.MaxPacketLen)
|
||||||
|
var h header.H
|
||||||
|
require.NoError(t, h.Parse(p))
|
||||||
|
assert.Equal(t, pqSubtype, h.Subtype)
|
||||||
|
assert.Equal(t, remoteIndex, h.RemoteIndex)
|
||||||
|
assert.Equal(t, uint64(2), h.MessageCounter)
|
||||||
|
fh, _, err := fragment.Parse(p[header.Len:])
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.Equal(t, fragID, fh.FragID)
|
||||||
|
out = append(out, int(fh.Index))
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestSendFragmentedResponse(t *testing.T) {
|
||||||
|
hm, conn := newPQTestManager(t)
|
||||||
|
via := ViaSender{UdpAddr: netip.MustParseAddrPort("192.0.2.1:4242")}
|
||||||
|
hostinfo := &HostInfo{localIndexId: 77}
|
||||||
|
|
||||||
|
// A 2000 byte message is 2 symbols of 1000, so packets of 1024 bytes.
|
||||||
|
msg := make([]byte, header.Len, header.Len+2000)
|
||||||
|
header.Encode(msg, header.Version, header.Handshake, pqSubtype, 5, 2)
|
||||||
|
r := rand.New(rand.NewPCG(1, 1))
|
||||||
|
for range 2000 {
|
||||||
|
msg = append(msg, byte(r.Uint32()))
|
||||||
|
}
|
||||||
|
const pktLen = header.Len + fragment.HeaderLen + 1000
|
||||||
|
|
||||||
|
t.Run("first send", func(t *testing.T) {
|
||||||
|
require.NoError(t, hm.sendFragmentedResponse(via, msg, hostinfo, false, 0))
|
||||||
|
assert.Equal(t, []int{0, 1, 2, 3}, fragmentIndexes(t, conn.take(), 77, 5))
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("resends are rate limited", func(t *testing.T) {
|
||||||
|
require.Error(t, hm.sendFragmentedResponse(via, msg, hostinfo, true, 10*pktLen))
|
||||||
|
assert.Empty(t, conn.take())
|
||||||
|
})
|
||||||
|
|
||||||
|
allowResend := func() {
|
||||||
|
hostinfo.handshakeResendAt.Store(time.Now().Add(-time.Second).UnixNano())
|
||||||
|
}
|
||||||
|
|
||||||
|
t.Run("resend offers fresh symbols", func(t *testing.T) {
|
||||||
|
allowResend()
|
||||||
|
require.NoError(t, hm.sendFragmentedResponse(via, msg, hostinfo, true, 10*pktLen))
|
||||||
|
assert.Equal(t, []int{4, 5, 6, 7}, fragmentIndexes(t, conn.take(), 77, 5))
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("amplification budget trims repair", func(t *testing.T) {
|
||||||
|
allowResend()
|
||||||
|
// 3x of a little over one packet allows 3 packets: both data and 1 repair.
|
||||||
|
require.NoError(t, hm.sendFragmentedResponse(via, msg, hostinfo, true, pktLen+10))
|
||||||
|
assert.Equal(t, []int{8, 9, 10}, fragmentIndexes(t, conn.take(), 77, 5))
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("amplification budget below the data refuses", func(t *testing.T) {
|
||||||
|
allowResend()
|
||||||
|
require.Error(t, hm.sendFragmentedResponse(via, msg, hostinfo, true, pktLen/2))
|
||||||
|
assert.Empty(t, conn.take())
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPQAnswered(t *testing.T) {
|
||||||
|
now := time.Unix(1000, 0)
|
||||||
|
a := newPQAnswered(5 * time.Second)
|
||||||
|
hi := &HostInfo{}
|
||||||
|
|
||||||
|
assert.Nil(t, a.lookup([]byte("msg1"), now))
|
||||||
|
a.add([]byte("msg1"), hi, now)
|
||||||
|
assert.Same(t, hi, a.lookup([]byte("msg1"), now.Add(time.Second)))
|
||||||
|
assert.Nil(t, a.lookup([]byte("other"), now))
|
||||||
|
assert.Nil(t, a.lookup([]byte("msg1"), now.Add(6*time.Second)), "stale entries are not answered")
|
||||||
|
|
||||||
|
a.expire(now.Add(6 * time.Second))
|
||||||
|
assert.Empty(t, a.entries)
|
||||||
|
|
||||||
|
for i := range pqAnsweredMax + 10 {
|
||||||
|
a.add([]byte{byte(i), byte(i >> 8)}, hi, now)
|
||||||
|
}
|
||||||
|
assert.Len(t, a.entries, pqAnsweredMax)
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPQFragKeyFor(t *testing.T) {
|
||||||
|
k1, s1 := pqFragKeyFor(ViaSender{UdpAddr: netip.MustParseAddrPort("192.0.2.1:4242")}, 9)
|
||||||
|
k2, s2 := pqFragKeyFor(ViaSender{UdpAddr: netip.MustParseAddrPort("192.0.2.1:4243")}, 9)
|
||||||
|
assert.NotEqual(t, k1, k2, "different ports are different messages")
|
||||||
|
assert.Equal(t, s1, s2, "but share an IPv4 /32 quota")
|
||||||
|
|
||||||
|
_, s3 := pqFragKeyFor(ViaSender{UdpAddr: netip.MustParseAddrPort("[2001:db8::1]:1")}, 9)
|
||||||
|
_, s4 := pqFragKeyFor(ViaSender{UdpAddr: netip.MustParseAddrPort("[2001:db8::ffff]:1")}, 9)
|
||||||
|
assert.Equal(t, s3, s4, "an IPv6 /64 shares a quota")
|
||||||
|
|
||||||
|
_, s5 := pqFragKeyFor(ViaSender{UdpAddr: netip.MustParseAddrPort("[::ffff:192.0.2.1]:1")}, 9)
|
||||||
|
assert.Equal(t, s1, s5, "v4-mapped addresses count as IPv4")
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPQCookies(t *testing.T) {
|
||||||
|
now := time.Unix(1000, 0)
|
||||||
|
c := newPQCookies(now)
|
||||||
|
key := pqFragKey{addr: netip.MustParseAddrPort("192.0.2.1:4242"), fragID: 9}
|
||||||
|
|
||||||
|
cookie := c.make(key, now)
|
||||||
|
assert.True(t, c.valid(key, cookie, now))
|
||||||
|
|
||||||
|
for _, other := range []pqFragKey{
|
||||||
|
{addr: netip.MustParseAddrPort("192.0.2.2:4242"), fragID: 9},
|
||||||
|
{addr: netip.MustParseAddrPort("192.0.2.1:4243"), fragID: 9},
|
||||||
|
{addr: netip.MustParseAddrPort("192.0.2.1:4242"), fragID: 10},
|
||||||
|
{addr: netip.MustParseAddrPort("192.0.2.1:4242"), relay: 1, fragID: 9},
|
||||||
|
} {
|
||||||
|
assert.False(t, c.valid(other, cookie, now), "%+v", other)
|
||||||
|
}
|
||||||
|
|
||||||
|
now = now.Add(pqCookieRotate)
|
||||||
|
assert.True(t, c.valid(key, cookie, now), "the previous secret is still accepted")
|
||||||
|
assert.NotEqual(t, cookie, c.make(key, now), "new cookies come from the new secret")
|
||||||
|
|
||||||
|
now = now.Add(pqCookieRotate)
|
||||||
|
assert.False(t, c.valid(key, cookie, now), "two rotations retire a cookie")
|
||||||
|
}
|
||||||
|
|
||||||
|
// pqMsg1Fragment builds the first fragment of a msg1, optionally with a cookie.
|
||||||
|
func pqMsg1Fragment(t *testing.T, fragID uint32, cookie *fragment.Cookie) ([]byte, *header.H) {
|
||||||
|
t.Helper()
|
||||||
|
s, err := fragment.NewSender(make([]byte, 2000), pqSubtype, 0, 1, fragID)
|
||||||
|
require.NoError(t, err)
|
||||||
|
if cookie != nil {
|
||||||
|
s.SetCookie(*cookie)
|
||||||
|
}
|
||||||
|
pkts, _, err := s.Attempt(0)
|
||||||
|
require.NoError(t, err)
|
||||||
|
var h header.H
|
||||||
|
require.NoError(t, h.Parse(pkts[0]))
|
||||||
|
return pkts[0], &h
|
||||||
|
}
|
||||||
|
|
||||||
|
// fillPQTable puts the responder's msg1 table at the cookie threshold.
|
||||||
|
func fillPQTable(t *testing.T, hm *HandshakeManager) {
|
||||||
|
t.Helper()
|
||||||
|
now := time.Now()
|
||||||
|
for i := 0; hm.pqTable.Load() < pqCookieLoad; i++ {
|
||||||
|
p, _ := pqMsg1Fragment(t, uint32(i+1), nil)
|
||||||
|
fh, sym, err := fragment.Parse(p[header.Len:])
|
||||||
|
require.NoError(t, err)
|
||||||
|
addr := netip.AddrPortFrom(netip.AddrFrom4([4]byte{198, 18, byte(i >> 8), byte(i)}), 4242)
|
||||||
|
key, src := pqFragKeyFor(ViaSender{UdpAddr: addr}, fh.FragID)
|
||||||
|
_, err = hm.pqTable.Add(key, src, now, fh, sym)
|
||||||
|
require.NoError(t, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPQCookieUnderLoad(t *testing.T) {
|
||||||
|
hm, conn := newPQTestManager(t)
|
||||||
|
via := ViaSender{UdpAddr: netip.MustParseAddrPort("192.0.2.1:4242")}
|
||||||
|
|
||||||
|
t.Run("no cookie needed below the threshold", func(t *testing.T) {
|
||||||
|
p, h := pqMsg1Fragment(t, 5000, nil)
|
||||||
|
before := hm.pqTable.Len()
|
||||||
|
hm.handleFragment(via, p, h)
|
||||||
|
assert.Empty(t, conn.take())
|
||||||
|
assert.Equal(t, before+1, hm.pqTable.Len())
|
||||||
|
})
|
||||||
|
|
||||||
|
fillPQTable(t, hm)
|
||||||
|
|
||||||
|
var cookie fragment.Cookie
|
||||||
|
t.Run("a fragment without a cookie gets one and leaves no state", func(t *testing.T) {
|
||||||
|
p, h := pqMsg1Fragment(t, 7, nil)
|
||||||
|
before := hm.pqTable.Len()
|
||||||
|
hm.handleFragment(via, p, h)
|
||||||
|
assert.Equal(t, before, hm.pqTable.Len())
|
||||||
|
|
||||||
|
sent := conn.take()
|
||||||
|
require.Len(t, sent, 1)
|
||||||
|
reply := sent[0]
|
||||||
|
require.Len(t, reply, pqCookieReplyLen)
|
||||||
|
var rh header.H
|
||||||
|
require.NoError(t, rh.Parse(reply))
|
||||||
|
assert.Equal(t, header.Handshake, rh.Type)
|
||||||
|
assert.Equal(t, pqSubtype, rh.Subtype)
|
||||||
|
assert.Equal(t, uint32(7), rh.RemoteIndex, "the reply names the initiator's FragID")
|
||||||
|
assert.Equal(t, uint64(pqCookieCounter), rh.MessageCounter)
|
||||||
|
copy(cookie[:], reply[header.Len:])
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("a forged cookie gets a fresh one", func(t *testing.T) {
|
||||||
|
bad := cookie
|
||||||
|
bad[0] ^= 1
|
||||||
|
p, h := pqMsg1Fragment(t, 7, &bad)
|
||||||
|
before := hm.pqTable.Len()
|
||||||
|
hm.handleFragment(via, p, h)
|
||||||
|
assert.Equal(t, before, hm.pqTable.Len())
|
||||||
|
assert.Len(t, conn.take(), 1)
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("the cookie gets the fragment in", func(t *testing.T) {
|
||||||
|
p, h := pqMsg1Fragment(t, 7, &cookie)
|
||||||
|
before := hm.pqTable.Len()
|
||||||
|
hm.handleFragment(via, p, h)
|
||||||
|
assert.Equal(t, before+1, hm.pqTable.Len())
|
||||||
|
assert.Empty(t, conn.take())
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("a cookie is bound to its address", func(t *testing.T) {
|
||||||
|
p, h := pqMsg1Fragment(t, 7, &cookie)
|
||||||
|
hm.handleFragment(ViaSender{UdpAddr: netip.MustParseAddrPort("192.0.2.99:4242")}, p, h)
|
||||||
|
assert.Len(t, conn.take(), 1, "another address gets its own cookie instead")
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("a reply never outgrows what prompted it", func(t *testing.T) {
|
||||||
|
p, h := pqMsg1Fragment(t, 8, nil)
|
||||||
|
hm.sendCookie(via, fragment.Header{FragID: 8}, pqFragKey{}, pqCookieReplyLen-1, time.Now())
|
||||||
|
assert.Empty(t, conn.take())
|
||||||
|
hm.handleFragment(via, p, h)
|
||||||
|
assert.Len(t, conn.take(), 1)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestPQHandleCookie(t *testing.T) {
|
||||||
|
hm, conn := newPQTestManager(t)
|
||||||
|
via := ViaSender{UdpAddr: netip.MustParseAddrPort("192.0.2.1:4242")}
|
||||||
|
|
||||||
|
s, err := fragment.NewSender(make([]byte, 2000), pqSubtype, 0, 1, 99)
|
||||||
|
require.NoError(t, err)
|
||||||
|
_, _, err = s.Attempt(2)
|
||||||
|
require.NoError(t, err)
|
||||||
|
hh := &HandshakeHostInfo{hostinfo: &HostInfo{}, pq: &pqAttempt{index: 99, sender: s}}
|
||||||
|
hm.indexes[99] = hh
|
||||||
|
|
||||||
|
reply := make([]byte, header.Len, pqCookieReplyLen)
|
||||||
|
header.Encode(reply, header.Version, header.Handshake, pqSubtype, 99, pqCookieCounter)
|
||||||
|
reply = append(reply, bytes16(0xab)...)
|
||||||
|
var h header.H
|
||||||
|
require.NoError(t, h.Parse(reply))
|
||||||
|
|
||||||
|
hm.handleFragment(via, reply, &h)
|
||||||
|
assert.True(t, hh.pq.heard, "a cookie reply shows the peer speaks PQ")
|
||||||
|
sent := conn.take()
|
||||||
|
require.Len(t, sent, 4, "an immediate resend of fresh symbols")
|
||||||
|
for i, p := range sent {
|
||||||
|
fh, _, err := fragment.Parse(p[header.Len:])
|
||||||
|
require.NoError(t, err)
|
||||||
|
assert.True(t, fh.HasCookie())
|
||||||
|
assert.Equal(t, fragment.Cookie(bytes16(0xab)), fh.Cookie)
|
||||||
|
assert.Equal(t, uint8(4+i), fh.Index)
|
||||||
|
}
|
||||||
|
|
||||||
|
hm.handleFragment(via, reply, &h)
|
||||||
|
assert.Empty(t, conn.take(), "immediate resends are rate limited")
|
||||||
|
|
||||||
|
t.Run("replies for other indexes are ignored", func(t *testing.T) {
|
||||||
|
other := append([]byte(nil), reply...)
|
||||||
|
header.Encode(other, header.Version, header.Handshake, pqSubtype, 98, pqCookieCounter)
|
||||||
|
var oh header.H
|
||||||
|
require.NoError(t, oh.Parse(other))
|
||||||
|
hh.pq.cookieResendAt = time.Time{}
|
||||||
|
hm.handleFragment(via, other, &oh)
|
||||||
|
assert.Empty(t, conn.take())
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func bytes16(b byte) []byte {
|
||||||
|
out := make([]byte, 16)
|
||||||
|
for i := range out {
|
||||||
|
out[i] = b
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestReloadPQ(t *testing.T) {
|
||||||
|
l := test.NewLogger()
|
||||||
|
c := config.NewC(l)
|
||||||
|
require.NoError(t, c.LoadString(`handshakes: {pq: {initiate: false}}`))
|
||||||
|
cfg := defaultHandshakeConfig
|
||||||
|
cfg.pq = pqHandshakeConfigFrom(c)
|
||||||
|
hm := NewHandshakeManager(l, newHostMap(l), newTestLighthouse(), &udp.NoopConn{}, cfg)
|
||||||
|
c.RegisterReloadCallback(hm.reloadPQ)
|
||||||
|
|
||||||
|
assert.Equal(t, pqHandshakeConfig{repairDelay: DefaultPQRepairDelay}, *hm.pqConfig())
|
||||||
|
|
||||||
|
require.NoError(t, c.ReloadConfigString(`handshakes: {pq: {initiate: true, accept: true, sticky: true, repair_delay: 25ms}}`))
|
||||||
|
assert.Equal(t, pqHandshakeConfig{initiate: true, accept: true, sticky: true, repairDelay: 25 * time.Millisecond}, *hm.pqConfig())
|
||||||
|
|
||||||
|
before := hm.pqConfig()
|
||||||
|
require.NoError(t, c.ReloadConfigString(`handshakes: {try_interval: 1s, pq: {initiate: true, accept: true, sticky: true, repair_delay: 25ms}}`))
|
||||||
|
assert.Same(t, before, hm.pqConfig(), "an unrelated change leaves the settings alone")
|
||||||
|
|
||||||
|
require.NoError(t, c.ReloadConfigString(`handshakes: {}`))
|
||||||
|
assert.Equal(t, pqHandshakeConfig{repairDelay: DefaultPQRepairDelay}, *hm.pqConfig(), "removing the section restores the defaults")
|
||||||
|
|
||||||
|
require.NoError(t, c.ReloadConfigString(`handshakes: {pq: {require: true}}`))
|
||||||
|
assert.Equal(t, pqHandshakeConfig{initiate: true, accept: true, require: true, repairDelay: DefaultPQRepairDelay}, *hm.pqConfig(), "require implies initiate and accept")
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestUsePQ(t *testing.T) {
|
||||||
|
hm, _ := newPQTestManager(t)
|
||||||
|
peer := netip.MustParseAddr("10.1.0.1")
|
||||||
|
set := func(cfg pqHandshakeConfig) { hm.pq.Store(&cfg) }
|
||||||
|
|
||||||
|
// attempts plays a run of attempts, given whether each was triggered early,
|
||||||
|
// and returns which were PQ.
|
||||||
|
attempts := func(triggered ...bool) []bool {
|
||||||
|
hh := &HandshakeHostInfo{}
|
||||||
|
var out []bool
|
||||||
|
for _, tr := range triggered {
|
||||||
|
hh.counter++
|
||||||
|
hh.lastPQ = hm.usePQ(hh, peer, tr)
|
||||||
|
out = append(out, hh.lastPQ)
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
set(pqHandshakeConfig{})
|
||||||
|
assert.Equal(t, []bool{false, false, false}, attempts(false, false, false), "off")
|
||||||
|
|
||||||
|
set(pqHandshakeConfig{initiate: true})
|
||||||
|
assert.Equal(t, []bool{true, false, true, false}, attempts(false, false, false, false), "timer retries alternate, PQ first")
|
||||||
|
assert.Equal(t, []bool{true, true, false, true, false}, attempts(false, true, false, true, false), "an early trigger is a new path, which gets PQ first")
|
||||||
|
assert.Equal(t, []bool{true, true, false}, attempts(true, true, false), "a triggered first attempt is PQ")
|
||||||
|
|
||||||
|
t.Run("hearing back stops the classical turns", func(t *testing.T) {
|
||||||
|
hh := &HandshakeHostInfo{pq: &pqAttempt{}}
|
||||||
|
hh.counter, hh.lastPQ = 1, true
|
||||||
|
hh.counter++
|
||||||
|
assert.False(t, hm.usePQ(hh, peer, false), "unheard, the classical attempt gets its turn")
|
||||||
|
hh.pq.heard = true
|
||||||
|
assert.True(t, hm.usePQ(hh, peer, false))
|
||||||
|
})
|
||||||
|
|
||||||
|
set(pqHandshakeConfig{initiate: true, accept: true, require: true})
|
||||||
|
assert.Equal(t, []bool{true, true, true, true}, attempts(false, false, true, false), "require never offers classical")
|
||||||
|
|
||||||
|
set(pqHandshakeConfig{initiate: true, sticky: true})
|
||||||
|
assert.Equal(t, []bool{true, false}, attempts(false, false), "sticky alternates until the peer has done PQ")
|
||||||
|
hm.notePQPeer(pqSubtype, []netip.Addr{peer})
|
||||||
|
assert.Equal(t, []bool{true, true, true}, attempts(false, false, false), "then only PQ")
|
||||||
|
}
|
||||||
@@ -11,6 +11,7 @@ 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) {
|
||||||
@@ -42,8 +43,6 @@ 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)
|
||||||
|
|
||||||
@@ -84,7 +83,7 @@ func (mw *mockEncWriter) SendMessageToVpnAddr(_ header.MessageType, _ header.Mes
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
func (mw *mockEncWriter) SendVia(_ *HostInfo, _ *Relay, _, _, _ []byte, _ bool) {
|
func (mw *mockEncWriter) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool, q int) {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -235,3 +234,70 @@ 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)
|
||||||
|
}
|
||||||
+28
-6
@@ -24,6 +24,11 @@ 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
|
||||||
@@ -62,8 +67,19 @@ const (
|
|||||||
const (
|
const (
|
||||||
HandshakeIXPSK0 MessageSubType = 0
|
HandshakeIXPSK0 MessageSubType = 0
|
||||||
HandshakeXXPSK0 MessageSubType = 1
|
HandshakeXXPSK0 MessageSubType = 1
|
||||||
|
|
||||||
|
// HandshakeIXPSK2MLKEM1024 is IX with an ephemeral ML-KEM-1024 exchange mixed
|
||||||
|
// in through the psk2 slot. Its messages exceed the MTU and travel as
|
||||||
|
// fragments (see handshake/fragment).
|
||||||
|
HandshakeIXPSK2MLKEM1024 MessageSubType = 2
|
||||||
)
|
)
|
||||||
|
|
||||||
|
// IsFragmented reports whether handshake messages of this subtype travel as
|
||||||
|
// fragments.
|
||||||
|
func IsFragmented(st MessageSubType) bool {
|
||||||
|
return st == HandshakeIXPSK2MLKEM1024
|
||||||
|
}
|
||||||
|
|
||||||
var ErrHeaderTooShort = errors.New("header is too short")
|
var ErrHeaderTooShort = errors.New("header is too short")
|
||||||
|
|
||||||
var subTypeTestMap = map[MessageSubType]string{
|
var subTypeTestMap = map[MessageSubType]string{
|
||||||
@@ -84,6 +100,7 @@ var subTypeMap = map[MessageType]*map[MessageSubType]string{
|
|||||||
CloseTunnel: &subTypeNoneMap,
|
CloseTunnel: &subTypeNoneMap,
|
||||||
Handshake: {
|
Handshake: {
|
||||||
HandshakeIXPSK0: "ix_psk0",
|
HandshakeIXPSK0: "ix_psk0",
|
||||||
|
HandshakeIXPSK2MLKEM1024: "ix_psk2_mlkem1024",
|
||||||
},
|
},
|
||||||
Control: &subTypeNoneMap,
|
Control: &subTypeNoneMap,
|
||||||
}
|
}
|
||||||
@@ -190,13 +207,18 @@ func SubTypeName(t MessageType, s MessageSubType) string {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func IsValidSubType(t MessageType, s MessageSubType) bool {
|
func IsValidSubType(t MessageType, s MessageSubType) bool {
|
||||||
if n, ok := subTypeMap[t]; ok {
|
switch t {
|
||||||
if _, ok := (*n)[s]; ok {
|
case Message:
|
||||||
return true
|
return s == MessageNone || s == MessageRelay
|
||||||
}
|
case Handshake:
|
||||||
}
|
return s == HandshakeIXPSK0 || s == HandshakeIXPSK2MLKEM1024
|
||||||
|
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
|
||||||
|
|||||||
@@ -97,11 +97,64 @@ func TestTypeMap(t *testing.T) {
|
|||||||
CloseTunnel: &subTypeNoneMap,
|
CloseTunnel: &subTypeNoneMap,
|
||||||
Handshake: {
|
Handshake: {
|
||||||
HandshakeIXPSK0: "ix_psk0",
|
HandshakeIXPSK0: "ix_psk0",
|
||||||
|
HandshakeIXPSK2MLKEM1024: "ix_psk2_mlkem1024",
|
||||||
},
|
},
|
||||||
Control: &subTypeNoneMap,
|
Control: &subTypeNoneMap,
|
||||||
}, 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))
|
||||||
|
assert.True(t, IsValidSubType(Handshake, HandshakeIXPSK2MLKEM1024))
|
||||||
|
// 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,
|
||||||
|
|||||||
+81
-69
@@ -6,7 +6,6 @@ import (
|
|||||||
"errors"
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"log/slog"
|
"log/slog"
|
||||||
"net"
|
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"slices"
|
"slices"
|
||||||
"sync"
|
"sync"
|
||||||
@@ -18,7 +17,6 @@ import (
|
|||||||
"github.com/slackhq/nebula/cert"
|
"github.com/slackhq/nebula/cert"
|
||||||
"github.com/slackhq/nebula/config"
|
"github.com/slackhq/nebula/config"
|
||||||
"github.com/slackhq/nebula/header"
|
"github.com/slackhq/nebula/header"
|
||||||
"github.com/slackhq/nebula/logging"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
const defaultPromoteEvery = 1000 // Count of packets sent before we try moving a tunnel to a preferred underlay ip address
|
const defaultPromoteEvery = 1000 // Count of packets sent before we try moving a tunnel to a preferred underlay ip address
|
||||||
@@ -239,11 +237,15 @@ const (
|
|||||||
|
|
||||||
type HostInfo struct {
|
type HostInfo struct {
|
||||||
remote atomic.Pointer[netip.AddrPort]
|
remote atomic.Pointer[netip.AddrPort]
|
||||||
remotes *RemoteList
|
|
||||||
promoteCounter atomic.Uint32
|
|
||||||
ConnectionState *ConnectionState
|
ConnectionState *ConnectionState
|
||||||
|
|
||||||
|
// Traffic bits, pendingDeletion, and the rebind epoch we last sent under
|
||||||
|
state atomic.Uint32
|
||||||
|
|
||||||
|
promoteCounter atomic.Uint32
|
||||||
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
|
||||||
@@ -258,15 +260,15 @@ type HostInfo struct {
|
|||||||
// We need these to avoid replayed handshake packets creating new hostinfos which causes churn
|
// We need these to avoid replayed handshake packets creating new hostinfos which causes churn
|
||||||
HandshakePacket map[uint8][]byte
|
HandshakePacket map[uint8][]byte
|
||||||
|
|
||||||
|
// A responder resending a fragmented handshake response offers symbols it has
|
||||||
|
// not sent before, at most once per retry interval.
|
||||||
|
handshakeResendAt atomic.Int64 // unix nanos of the last send
|
||||||
|
handshakeNextSymbol atomic.Uint32 // next fragment symbol index to offer
|
||||||
|
|
||||||
// nextLHQuery is the earliest we can ask the lighthouse for new information.
|
// nextLHQuery is the earliest we can ask the lighthouse for new information.
|
||||||
// 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
|
||||||
@@ -275,9 +277,6 @@ 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.
|
||||||
@@ -543,6 +542,17 @@ 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 {
|
||||||
@@ -658,7 +668,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.out.Store(true)
|
hostinfo.markOut(f.rebindEpoch.Load())
|
||||||
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)
|
||||||
}
|
}
|
||||||
@@ -759,6 +769,64 @@ 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
|
||||||
@@ -865,59 +933,3 @@ func (i *HostInfo) logger(l *slog.Logger) *slog.Logger {
|
|||||||
|
|
||||||
return li
|
return li
|
||||||
}
|
}
|
||||||
|
|
||||||
// Utility functions
|
|
||||||
|
|
||||||
func localAddrs(l *slog.Logger, allowList *LocalAllowList) []netip.Addr {
|
|
||||||
//FIXME: This function is pretty garbage
|
|
||||||
var finalAddrs []netip.Addr
|
|
||||||
ifaces, _ := net.Interfaces()
|
|
||||||
for _, i := range ifaces {
|
|
||||||
allow := allowList.AllowName(i.Name)
|
|
||||||
if l.Enabled(context.Background(), logging.LevelTrace) {
|
|
||||||
l.Log(context.Background(), logging.LevelTrace, "localAllowList.AllowName",
|
|
||||||
"interfaceName", i.Name,
|
|
||||||
"allow", allow,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !allow {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
addrs, _ := i.Addrs()
|
|
||||||
for _, rawAddr := range addrs {
|
|
||||||
var addr netip.Addr
|
|
||||||
switch v := rawAddr.(type) {
|
|
||||||
case *net.IPNet:
|
|
||||||
//continue
|
|
||||||
addr, _ = netip.AddrFromSlice(v.IP)
|
|
||||||
case *net.IPAddr:
|
|
||||||
addr, _ = netip.AddrFromSlice(v.IP)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !addr.IsValid() {
|
|
||||||
if l.Enabled(context.Background(), slog.LevelDebug) {
|
|
||||||
l.Debug("addr was invalid", "localAddr", rawAddr)
|
|
||||||
}
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
addr = addr.Unmap()
|
|
||||||
|
|
||||||
if addr.IsLoopback() == false && addr.IsLinkLocalUnicast() == false {
|
|
||||||
isAllowed := allowList.Allow(addr)
|
|
||||||
if l.Enabled(context.Background(), logging.LevelTrace) {
|
|
||||||
l.Log(context.Background(), logging.LevelTrace, "localAllowList.Allow",
|
|
||||||
"localAddr", addr,
|
|
||||||
"allowed", isAllowed,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
if !isAllowed {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
finalAddrs = append(finalAddrs, addr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return finalAddrs
|
|
||||||
}
|
|
||||||
@@ -401,3 +401,49 @@ 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,17 +2,34 @@ 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(packet []byte, fwPacket *firewall.Packet, nb, out []byte, q int, localCache firewall.ConntrackCache) {
|
func (f *Interface) consumeInsidePacket(pkt tio.Packet, fwPacket *firewall.ParsedPacket, nb []byte, sendBatch *batch.SendBatch, rejectBuf []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) {
|
||||||
@@ -37,7 +54,17 @@ func (f *Interface) consumeInsidePacket(packet []byte, fwPacket *firewall.Packet
|
|||||||
// routes packets from the Nebula addr to the Nebula addr through the Nebula
|
// routes packets from the Nebula addr to the Nebula addr through the Nebula
|
||||||
// TUN device.
|
// TUN device.
|
||||||
if immediatelyForwardToSelf {
|
if immediatelyForwardToSelf {
|
||||||
_, err := f.readers[q].Write(packet)
|
// Write copies into the kernel queue synchronously, so seg's lifetime ends at return.
|
||||||
|
// 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)
|
||||||
}
|
}
|
||||||
@@ -52,12 +79,24 @@ func (f *Interface) consumeInsidePacket(packet []byte, fwPacket *firewall.Packet
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
hostinfo, ready := f.getOrHandshakeConsiderRouting(fwPacket, func(hh *HandshakeHostInfo) {
|
hostinfo, ready := f.getOrHandshakeConsiderRouting(&fwPacket.Packet, func(hh *HandshakeHostInfo) {
|
||||||
hh.cachePacket(f.l, header.Message, 0, packet, f.sendMessageNow, f.cachedPacketMetrics)
|
// borrowed: SegmentSuperpacket builds each segment in the kernel-supplied pkt
|
||||||
|
// 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, out, q)
|
f.rejectInside(packet, rejectBuf, 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,
|
||||||
@@ -71,12 +110,11 @@ func (f *Interface) consumeInsidePacket(packet []byte, fwPacket *firewall.Packet
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
dropReason := f.firewall.Drop(*fwPacket, false, hostinfo, f.pki.GetCAPool(), localCache)
|
dropReason := f.firewall.Drop(fwPacket.Packet, false, hostinfo, f.pki.GetCAPool(), localCache)
|
||||||
if dropReason == nil {
|
if dropReason == nil {
|
||||||
f.sendNoMetrics(header.Message, 0, hostinfo.ConnectionState, hostinfo, netip.AddrPort{}, packet, nb, out, q)
|
f.sendInsideMessage(hostinfo, pkt, nb, sendBatch)
|
||||||
|
|
||||||
} else {
|
} else {
|
||||||
f.rejectInside(packet, out, q)
|
f.rejectInside(packet, rejectBuf, 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,
|
||||||
@@ -86,6 +124,122 @@ func (f *Interface) consumeInsidePacket(packet []byte, fwPacket *firewall.Packet
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
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
|
||||||
@@ -96,33 +250,36 @@ func (f *Interface) rejectInside(packet []byte, out []byte, q int) {
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
_, err := f.readers[q].Write(out)
|
_, err := f.queues[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, out []byte, q int) {
|
func (f *Interface) rejectOutside(packet []byte, ci *ConnectionState, hostinfo *HostInfo, nb, rejectBuf []byte, q int) {
|
||||||
if !f.firewall.InboundSendReject {
|
if !f.firewall.InboundSendReject {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
out = iputil.CreateRejectPacket(packet, out)
|
// split rejectBuf to make sure we have room to write the plaintext rejection, then encrypt it, without trampling anything
|
||||||
|
// 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",
|
f.l.Info("rejectOutside: packet too big, not sending", "packet", packet, "outPacket", out)
|
||||||
"packet", packet,
|
|
||||||
"outPacket", out,
|
|
||||||
)
|
|
||||||
}
|
}
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
f.sendNoMetrics(header.Message, 0, ci, hostinfo, netip.AddrPort{}, out, nb, packet, q)
|
f.sendNoMetrics(header.Message, 0, ci, hostinfo, netip.AddrPort{}, out, nb, encryptBuf, 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
|
||||||
@@ -216,7 +373,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.Packet{}
|
fp := &firewall.ParsedPacket{}
|
||||||
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)
|
||||||
@@ -224,7 +381,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, false, hostinfo, f.pki.GetCAPool(), nil)
|
dropReason := f.firewall.Drop(fp.Packet, 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",
|
||||||
@@ -275,29 +432,36 @@ func (f *Interface) sendTo(t header.MessageType, st header.MessageSubType, ci *C
|
|||||||
f.sendNoMetrics(t, st, ci, hostinfo, remote, p, nb, out, 0)
|
f.sendNoMetrics(t, st, ci, hostinfo, remote, p, nb, out, 0)
|
||||||
}
|
}
|
||||||
|
|
||||||
// SendVia sends a payload through a Relay tunnel. No authentication or encryption is done
|
// dropExhausted records an exhaustion drop and logs once, on the crossing send, for a spent tunnel.
|
||||||
// to the payload for the ultimate target host, making this a useful method for sending
|
func (f *Interface) dropExhausted(hostinfo *HostInfo, c uint64, msg string) {
|
||||||
// handshake messages to peers through relay tunnels.
|
f.messageMetrics.TxExhausted(1)
|
||||||
// via is the HostInfo through which the message is relayed.
|
if c == RejectAfterMessages {
|
||||||
// ad is the plaintext data to authenticate, but not encrypt
|
hostinfo.logger(f.l).Error(msg)
|
||||||
// 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,
|
func (f *Interface) prepareSendVia(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()
|
||||||
}
|
}
|
||||||
c := via.ConnectionState.messageCounter.Add(1)
|
c, ok := via.ConnectionState.NextMessageCounter()
|
||||||
|
if !ok {
|
||||||
|
if noiseutil.EncryptLockNeeded {
|
||||||
|
via.ConnectionState.writeLock.Unlock()
|
||||||
|
}
|
||||||
|
f.dropExhausted(via, c, "Dropping outbound relay packets, tunnel message counter is exhausted")
|
||||||
|
return nil, fmt.Errorf("tunnel message counter is exhausted")
|
||||||
|
}
|
||||||
|
|
||||||
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.Out(via)
|
f.connectionManager.OutNoRebind(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.
|
||||||
@@ -311,7 +475,7 @@ func (f *Interface) SendVia(via *HostInfo,
|
|||||||
"headerLen", len(out),
|
"headerLen", len(out),
|
||||||
"cipherOverhead", via.ConnectionState.eKey.Overhead(),
|
"cipherOverhead", via.ConnectionState.eKey.Overhead(),
|
||||||
)
|
)
|
||||||
return
|
return nil, io.ErrShortBuffer
|
||||||
}
|
}
|
||||||
|
|
||||||
// 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.
|
||||||
@@ -331,13 +495,33 @@ func (f *Interface) SendVia(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
|
return nil, err
|
||||||
}
|
|
||||||
err = f.writers[0].WriteTo(out, via.GetRemote())
|
|
||||||
if err != nil {
|
|
||||||
via.logger(f.l).Info("Failed to WriteTo in sendVia", "error", err)
|
|
||||||
}
|
}
|
||||||
f.connectionManager.RelayUsed(relay.LocalIndex)
|
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
|
||||||
|
}
|
||||||
|
|
||||||
|
err = f.writers[q].WriteTo(toSend, via.GetRemote())
|
||||||
|
if err != nil {
|
||||||
|
if l, ok := logging.RateLimited(f.l, f.udpRelayTxErrLimiter); ok {
|
||||||
|
via.logger(l).Info("Failed to WriteTo in sendVia", "error", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
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) {
|
||||||
@@ -345,37 +529,50 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
useRelay := !remote.IsValid() && !hostinfo.GetRemote().IsValid()
|
useRelay := !remote.IsValid() && !hostinfo.GetRemote().IsValid()
|
||||||
fullOut := out
|
|
||||||
|
|
||||||
|
// 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 {
|
if useRelay {
|
||||||
if len(out) < header.Len {
|
// The relay tunnel runs the same cipher, and adds its own header and tag
|
||||||
// out always has a capacity of mtu, but not always a length greater than the header.Len.
|
need += header.Len + ci.eKey.Overhead()
|
||||||
// Grow it to make sure the next operation works.
|
|
||||||
out = out[:header.Len]
|
|
||||||
}
|
}
|
||||||
|
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
|
||||||
|
if useRelay {
|
||||||
// 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:]
|
out = out[header.Len:header.Len]
|
||||||
}
|
}
|
||||||
|
|
||||||
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
|
||||||
ci.writeLock.Lock()
|
ci.writeLock.Lock()
|
||||||
}
|
}
|
||||||
c := ci.messageCounter.Add(1)
|
c, ok := ci.NextMessageCounter()
|
||||||
|
if !ok {
|
||||||
|
if noiseutil.EncryptLockNeeded {
|
||||||
|
ci.writeLock.Unlock()
|
||||||
|
}
|
||||||
|
f.dropExhausted(hostinfo, c, "Dropping outbound packets, tunnel message counter is exhausted")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
//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)
|
||||||
f.connectionManager.Out(hostinfo)
|
// A closing tunnel is torn down right after this, so skip the connection manager entirely: no point recording
|
||||||
|
// traffic or asking the lighthouse for a punch. Otherwise, if we rebound since this tunnel last sent, ask the
|
||||||
// Query our LH if we haven't since the last time we've been rebound, this will cause the remote to punch against
|
// lighthouse to get the far side punching at us again.
|
||||||
// all our addrs and enable a faster roaming.
|
if t != header.CloseTunnel && f.connectionManager.Out(hostinfo) {
|
||||||
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 counter",
|
f.l.Debug("Lighthouse update triggered for punch due to rebind epoch",
|
||||||
"vpnAddrs", hostinfo.vpnAddrs,
|
"vpnAddrs", hostinfo.vpnAddrs,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -398,19 +595,23 @@ 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 {
|
||||||
hostinfo.logger(f.l).Error("Failed to write outgoing packet",
|
if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok {
|
||||||
|
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 {
|
||||||
hostinfo.logger(f.l).Error("Failed to write outgoing packet",
|
if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok {
|
||||||
|
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() {
|
||||||
@@ -423,7 +624,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)
|
f.SendVia(relayHostInfo, relay, out, nb, fullOut[:header.Len+len(out)], true, q)
|
||||||
break
|
break
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
+265
@@ -0,0 +1,265 @@
|
|||||||
|
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:]))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
+189
-58
@@ -2,11 +2,12 @@ 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"
|
||||||
@@ -14,12 +15,16 @@ 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"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -49,6 +54,18 @@ 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
|
||||||
|
// 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
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -73,6 +90,15 @@ 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
|
||||||
|
// 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
|
||||||
@@ -82,17 +108,27 @@ type Interface struct {
|
|||||||
sendRecvErrorConfig recvErrorConfig
|
sendRecvErrorConfig recvErrorConfig
|
||||||
acceptRecvErrorConfig recvErrorConfig
|
acceptRecvErrorConfig recvErrorConfig
|
||||||
|
|
||||||
// rebindCount is used to decide if an active tunnel should trigger a punch notification through a lighthouse
|
// Bumped on every udp rebind, tunnels compare it to decide they need a punch from the far side
|
||||||
rebindCount int8
|
rebindEpoch atomic.Uint32
|
||||||
version string
|
version string
|
||||||
|
|
||||||
conntrackCacheTimeout time.Duration
|
conntrackCacheTimeout time.Duration
|
||||||
|
|
||||||
ctx context.Context
|
ctx context.Context
|
||||||
writers []udp.Conn
|
writers []udp.Conn
|
||||||
readers []io.ReadWriteCloser
|
queues []tio.Queue
|
||||||
|
// 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]
|
||||||
@@ -102,18 +138,13 @@ 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,
|
SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool, q int)
|
||||||
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)
|
||||||
@@ -172,6 +203,23 @@ 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,
|
||||||
@@ -189,7 +237,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),
|
||||||
readers: make([]io.ReadWriteCloser, c.routines),
|
batchers: make([]*batch.MultiCoalescer, c.routines),
|
||||||
myVpnNetworks: cs.myVpnNetworks,
|
myVpnNetworks: cs.myVpnNetworks,
|
||||||
myVpnNetworksTable: cs.myVpnNetworksTable,
|
myVpnNetworksTable: cs.myVpnNetworksTable,
|
||||||
myVpnAddrs: cs.myVpnAddrs,
|
myVpnAddrs: cs.myVpnAddrs,
|
||||||
@@ -198,8 +246,14 @@ 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,
|
||||||
|
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),
|
||||||
@@ -238,27 +292,41 @@ 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 {
|
if f.routines > 1 && !f.outside.SupportsMultipleReaders() {
|
||||||
if !f.inside.SupportsMultiqueue() || !f.outside.SupportsMultipleReaders() {
|
|
||||||
f.routines = 1
|
f.routines = 1
|
||||||
f.l.Warn("routines is not supported on this platform, falling back to a single routine")
|
f.l.Warn("multiple udp readers are not supported on this platform, falling back to a single routine")
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
metrics.GetOrRegisterGauge("routines", nil).Update(int64(f.routines))
|
// 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
|
||||||
// Prepare n tun queues
|
// size the reader routines to what we actually got.
|
||||||
var reader io.ReadWriteCloser = f.inside
|
queues, err := f.inside.Queues(f.routines)
|
||||||
for i := 0; i < f.routines; i++ {
|
|
||||||
if i > 0 {
|
|
||||||
reader, err = f.inside.NewMultiQueueReader()
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
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.readers[i] = reader
|
f.queues = queues
|
||||||
|
|
||||||
|
metrics.GetOrRegisterGauge("routines", nil).Update(int64(f.routines))
|
||||||
|
|
||||||
|
for i := range f.queues {
|
||||||
|
f.batchers[i] = batch.NewMultiCoalescer(f.queues[i], f.l)
|
||||||
}
|
}
|
||||||
|
|
||||||
// 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
|
||||||
@@ -281,7 +349,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.readers[i], i)
|
f.listenIn(f.queues[i], i)
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -306,6 +374,31 @@ 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 {
|
||||||
@@ -314,16 +407,20 @@ func (f *Interface) listenOut(i int) {
|
|||||||
li = f.outside
|
li = f.outside
|
||||||
}
|
}
|
||||||
|
|
||||||
ctCache := firewall.NewConntrackCacheTicker(f.ctx, f.l, f.conntrackCacheTimeout)
|
rxc := newRxContext(f, i)
|
||||||
lhh := f.lightHouse.NewRequestHandler()
|
|
||||||
plaintext := make([]byte, udp.MTU)
|
|
||||||
h := &header.H{}
|
|
||||||
fwPacket := &firewall.Packet{}
|
|
||||||
nb := make([]byte, 12, 12)
|
|
||||||
|
|
||||||
err := li.ListenOut(func(fromUdpAddr netip.AddrPort, payload []byte) {
|
listener := func(fromUdpAddr netip.AddrPort, payload []byte) {
|
||||||
f.readOutsidePackets(ViaSender{UdpAddr: fromUdpAddr}, plaintext[:0], payload, h, fwPacket, lhh, nb, i, ctCache.Get())
|
f.readOutsidePackets(ViaSender{UdpAddr: fromUdpAddr}, payload, rxc)
|
||||||
})
|
}
|
||||||
|
|
||||||
|
flusher := func() {
|
||||||
|
if err := f.batchers[i].Flush(); err != nil {
|
||||||
|
f.l.Error("Failed to flush tun coalescer", "error", err)
|
||||||
|
}
|
||||||
|
clear(rxc.hostmapCache)
|
||||||
|
}
|
||||||
|
|
||||||
|
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
|
||||||
@@ -336,16 +433,42 @@ 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) listenIn(reader io.ReadWriteCloser, i int) {
|
func (f *Interface) pinThisThread(i int) {
|
||||||
packet := make([]byte, mtu)
|
var cpu int
|
||||||
out := make([]byte, mtu)
|
if n := len(f.cpuAffinity); n > 0 {
|
||||||
fwPacket := &firewall.Packet{}
|
// Explicit tun.cpu_affinity list wins; parseCpuAffinity already
|
||||||
|
// validated the entries against the allowed CPU set.
|
||||||
|
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.
|
||||||
|
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 {
|
||||||
n, err := reader.Read(packet)
|
pkts, err := queue.Read()
|
||||||
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 {
|
||||||
@@ -355,12 +478,35 @@ func (f *Interface) listenIn(reader io.ReadWriteCloser, i int) {
|
|||||||
break
|
break
|
||||||
}
|
}
|
||||||
|
|
||||||
f.consumeInsidePacket(packet[:n], fwPacket, nb, out, i, conntrackCache.Get())
|
for _, pkt := range pkts {
|
||||||
|
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)
|
||||||
@@ -499,17 +645,15 @@ func (f *Interface) reloadMisc(c *config.C) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (f *Interface) emitStats(ctx context.Context, i time.Duration) {
|
// statsEmitter updates the interface's gauges, the stats server runs it on its capture loop.
|
||||||
ticker := time.NewTicker(i)
|
func (f *Interface) statsEmitter() func() {
|
||||||
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)
|
||||||
|
|
||||||
emit := func() {
|
return func() {
|
||||||
f.firewall.EmitStats()
|
f.firewall.EmitStats()
|
||||||
f.handshakeManager.EmitStats()
|
f.handshakeManager.EmitStats()
|
||||||
udpStats()
|
udpStats()
|
||||||
@@ -526,19 +670,6 @@ func (f *Interface) emitStats(ctx context.Context, i time.Duration) {
|
|||||||
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 {
|
||||||
|
|||||||
+5
-14
@@ -3,7 +3,6 @@
|
|||||||
package nebula
|
package nebula
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"context"
|
|
||||||
"net/netip"
|
"net/netip"
|
||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
@@ -18,11 +17,8 @@ import (
|
|||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
)
|
)
|
||||||
|
|
||||||
// Test_emitStats_primesGauges covers issue #907: a Prometheus scrape that
|
// Priming before the first tick (issue #907) is Start's job, see TestStatsServer_Start_primes.
|
||||||
// landed before the first ticker fire used to read 0 for the cert gauges.
|
func Test_statsEmitter_setsGauges(t *testing.T) {
|
||||||
// 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()
|
||||||
@@ -56,17 +52,12 @@ func Test_emitStats_primesGauges(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 emitStats runs")
|
require.Zero(t, ttlGauge.Value(), "gauge should be zero before the emitter runs")
|
||||||
|
|
||||||
// Pre-cancel the context so emitStats returns after priming the gauges
|
ifce.statsEmitter()()
|
||||||
// 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 primed by emitStats before its first tick")
|
assert.Positive(t, ttl, "ttl gauge should be set by one run of the emitter")
|
||||||
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())
|
||||||
|
|||||||
@@ -0,0 +1,136 @@
|
|||||||
|
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)
|
||||||
|
}
|
||||||
@@ -0,0 +1,242 @@
|
|||||||
|
package iputil
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/binary"
|
||||||
|
"net"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/google/gopacket"
|
||||||
|
"github.com/google/gopacket/layers"
|
||||||
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
|
"golang.org/x/net/ipv6"
|
||||||
|
)
|
||||||
|
|
||||||
|
// serialize builds a packet with gopacket, whose checksums are computed
|
||||||
|
// independently of this package.
|
||||||
|
func serialize(t *testing.T, ls ...gopacket.SerializableLayer) []byte {
|
||||||
|
buf := gopacket.NewSerializeBuffer()
|
||||||
|
require.NoError(t, gopacket.SerializeLayers(buf, gopacket.SerializeOptions{FixLengths: true, ComputeChecksums: true}, ls...))
|
||||||
|
return append([]byte(nil), buf.Bytes()...)
|
||||||
|
}
|
||||||
|
|
||||||
|
// withExtensionHeader inserts an 8 byte IPv6 extension header of the given
|
||||||
|
// type between the IPv6 header and its payload. The transport checksum does not
|
||||||
|
// change: the pseudo-header counts only upper-layer bytes.
|
||||||
|
func withExtensionHeader(pkt []byte, typ layers.IPProtocol, hdr [8]byte) []byte {
|
||||||
|
hdr[0] = pkt[6]
|
||||||
|
out := make([]byte, 0, len(pkt)+8)
|
||||||
|
out = append(out, pkt[:40]...)
|
||||||
|
out = append(out, hdr[:]...)
|
||||||
|
out = append(out, pkt[40:]...)
|
||||||
|
out[6] = byte(typ)
|
||||||
|
binary.BigEndian.PutUint16(out[4:6], binary.BigEndian.Uint16(pkt[4:6])+8)
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// truncate copies the first n bytes into a buffer of exactly that capacity, so
|
||||||
|
// a read past the length panics instead of quietly succeeding.
|
||||||
|
func truncate(pkt []byte, n int) []byte {
|
||||||
|
out := make([]byte, n)
|
||||||
|
copy(out, pkt)
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// extChain builds an IPv6 packet fronted by n Destination Options headers. Each
|
||||||
|
// points at another one, so the walk spends its whole budget without reaching a
|
||||||
|
// transport header. lastExtLen inflates the final header's declared length,
|
||||||
|
// which is how the walk ends up past the end of the packet.
|
||||||
|
func extChain(n int, lastExtLen byte) []byte {
|
||||||
|
pkt := make([]byte, ipv6.HeaderLen)
|
||||||
|
pkt[0], pkt[6], pkt[7] = 0x60, 60, 64
|
||||||
|
for i := range n {
|
||||||
|
h := make([]byte, 8)
|
||||||
|
h[0] = 60
|
||||||
|
if i == n-1 {
|
||||||
|
h[1] = lastExtLen
|
||||||
|
}
|
||||||
|
pkt = append(pkt, h...)
|
||||||
|
}
|
||||||
|
pkt = append(pkt, make([]byte, 20)...)
|
||||||
|
binary.BigEndian.PutUint16(pkt[4:6], uint16(len(pkt)-ipv6.HeaderLen))
|
||||||
|
return pkt
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestSetTransportChecksum(t *testing.T) {
|
||||||
|
// Source and destination differ so that a pseudo-header built from the wrong
|
||||||
|
// one, or from the two swapped, does not land on the same checksum anyway.
|
||||||
|
v4 := func(proto layers.IPProtocol) *layers.IPv4 {
|
||||||
|
return &layers.IPv4{Version: 4, TTL: 64, Id: 0x1234, Protocol: proto, SrcIP: net.IPv4(192, 0, 2, 1).To4(), DstIP: net.IPv4(198, 51, 100, 2).To4()}
|
||||||
|
}
|
||||||
|
v6 := func(proto layers.IPProtocol) *layers.IPv6 {
|
||||||
|
return &layers.IPv6{Version: 6, HopLimit: 64, NextHeader: proto, SrcIP: net.ParseIP("2001:db8::1"), DstIP: net.ParseIP("2001:db8:1::2")}
|
||||||
|
}
|
||||||
|
tcp := func(ip gopacket.NetworkLayer) *layers.TCP {
|
||||||
|
l := &layers.TCP{SrcPort: 49152, DstPort: 443, SYN: true, Window: 65535}
|
||||||
|
require.NoError(t, l.SetNetworkLayerForChecksum(ip))
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
udp := func(ip gopacket.NetworkLayer) *layers.UDP {
|
||||||
|
l := &layers.UDP{SrcPort: 49152, DstPort: 53}
|
||||||
|
require.NoError(t, l.SetNetworkLayerForChecksum(ip))
|
||||||
|
return l
|
||||||
|
}
|
||||||
|
payload := gopacket.Payload("self")
|
||||||
|
nop := layers.IPv4Option{OptionType: 1, OptionLength: 1}
|
||||||
|
|
||||||
|
ip4tcp := v4(layers.IPProtocolTCP)
|
||||||
|
ip4opts := v4(layers.IPProtocolTCP)
|
||||||
|
ip4opts.Options = []layers.IPv4Option{nop, nop, nop, nop}
|
||||||
|
ip4udp := v4(layers.IPProtocolUDP)
|
||||||
|
ip6tcp := v6(layers.IPProtocolTCP)
|
||||||
|
ip6udp := v6(layers.IPProtocolUDP)
|
||||||
|
hopByHop := [8]byte{0, 0, 1, 4} // next header, length 0, PadN of 4
|
||||||
|
|
||||||
|
// Bytes past the length the IP header declares are not part of the
|
||||||
|
// datagram and must not be summed.
|
||||||
|
trailing4 := append(serialize(t, ip4tcp, tcp(ip4tcp), payload), []byte("trailing")...)
|
||||||
|
trailing6 := append(serialize(t, ip6tcp, tcp(ip6tcp), payload), []byte("trailing")...)
|
||||||
|
|
||||||
|
// A datagram padded out past the length UDP declares: the pseudo-header
|
||||||
|
// counts the UDP Length field, so the checksum is the unpadded one.
|
||||||
|
padded4 := append(serialize(t, ip4udp, udp(ip4udp), payload), []byte("pad!")...)
|
||||||
|
binary.BigEndian.PutUint16(padded4[2:4], uint16(len(padded4)))
|
||||||
|
padded6 := append(serialize(t, ip6udp, udp(ip6udp), payload), []byte("pad!")...)
|
||||||
|
binary.BigEndian.PutUint16(padded6[4:6], uint16(len(padded6)-ipv6.HeaderLen))
|
||||||
|
|
||||||
|
// Corrupting the checksum and asking for it back must yield gopacket's
|
||||||
|
// packet, byte for byte.
|
||||||
|
recomputed := []struct {
|
||||||
|
name string
|
||||||
|
pkt []byte
|
||||||
|
cksum int
|
||||||
|
}{
|
||||||
|
{"v4 tcp", serialize(t, ip4tcp, tcp(ip4tcp), payload), 20 + 16},
|
||||||
|
{"v4 tcp with ip options", serialize(t, ip4opts, tcp(ip4opts), payload), 24 + 16},
|
||||||
|
{"v4 udp", serialize(t, ip4udp, udp(ip4udp), payload), 20 + 6},
|
||||||
|
{"v4 tcp header only", serialize(t, ip4tcp, tcp(ip4tcp)), 20 + 16},
|
||||||
|
{"v4 udp header only", serialize(t, ip4udp, udp(ip4udp)), 20 + 6},
|
||||||
|
{"v6 tcp", serialize(t, ip6tcp, tcp(ip6tcp), payload), 40 + 16},
|
||||||
|
{"v6 udp", serialize(t, ip6udp, udp(ip6udp), payload), 40 + 6},
|
||||||
|
{"v6 udp header only", serialize(t, ip6udp, udp(ip6udp)), 40 + 6},
|
||||||
|
{"v6 tcp behind hop-by-hop", withExtensionHeader(serialize(t, ip6tcp, tcp(ip6tcp), payload), layers.IPProtocolIPv6HopByHop, hopByHop), 48 + 16},
|
||||||
|
{"v4 tcp with bytes past the total length", trailing4, 20 + 16},
|
||||||
|
{"v6 tcp with bytes past the payload length", trailing6, 40 + 16},
|
||||||
|
{"v4 udp padded past its declared length", padded4, 20 + 6},
|
||||||
|
{"v6 udp padded past its declared length", padded6, 40 + 6},
|
||||||
|
}
|
||||||
|
for _, tt := range recomputed {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
got := append([]byte(nil), tt.pkt...)
|
||||||
|
binary.BigEndian.PutUint16(got[tt.cksum:], 0x1234)
|
||||||
|
require.NotEqual(t, tt.pkt, got)
|
||||||
|
SetTransportChecksum(got)
|
||||||
|
assert.Equal(t, tt.pkt, got)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
ip4frag := v4(layers.IPProtocolTCP)
|
||||||
|
ip4frag.Flags = layers.IPv4MoreFragments
|
||||||
|
ip4later := v4(layers.IPProtocolTCP)
|
||||||
|
ip4later.FragOffset = 1
|
||||||
|
ip4icmp := v4(layers.IPProtocolICMPv4)
|
||||||
|
|
||||||
|
badIHL := serialize(t, ip4tcp, tcp(ip4tcp), payload)
|
||||||
|
badIHL[0] = 0x44 // header length 16, shorter than an ipv4 header
|
||||||
|
shortTotalLen := serialize(t, ip4tcp, tcp(ip4tcp), payload)
|
||||||
|
binary.BigEndian.PutUint16(shortTotalLen[2:4], 10) // shorter than the header it introduces
|
||||||
|
cutTCP := serialize(t, ip4tcp, tcp(ip4tcp), payload)
|
||||||
|
binary.BigEndian.PutUint16(cutTCP[2:4], 20+19) // one byte short of a tcp header
|
||||||
|
cutTCP = truncate(cutTCP, 20+19)
|
||||||
|
cutUDP := serialize(t, ip4udp, udp(ip4udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(cutUDP[2:4], 20+7) // one byte short of a udp header
|
||||||
|
cutUDP = truncate(cutUDP, 20+7)
|
||||||
|
// Two bytes short, so a transport header survives whole and the minimum
|
||||||
|
// length check cannot stand in for the bounds check.
|
||||||
|
cutV6 := truncate(serialize(t, ip6tcp, tcp(ip6tcp), payload), 62)
|
||||||
|
fragment := [8]byte{0, 0, 0, 1, 0, 0, 0, 1} // next header, reserved, offset 0 with M set, id
|
||||||
|
overrun4 := serialize(t, ip4udp, udp(ip4udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(overrun4[24:26], uint16(len(overrun4)-20+1)) // one byte past what ip delivered
|
||||||
|
overrun6 := serialize(t, ip6udp, udp(ip6udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(overrun6[44:46], uint16(len(overrun6)-ipv6.HeaderLen+1))
|
||||||
|
shortUDPLen := serialize(t, ip4udp, udp(ip4udp), payload)
|
||||||
|
binary.BigEndian.PutUint16(shortUDPLen[24:26], 7) // shorter than the header it counts
|
||||||
|
|
||||||
|
// Where the checksum cannot be completed the packet is left as it came.
|
||||||
|
untouched := []struct {
|
||||||
|
name string
|
||||||
|
pkt []byte
|
||||||
|
cksum int
|
||||||
|
}{
|
||||||
|
{"v4 first fragment", serialize(t, ip4frag, tcp(ip4frag), payload), 20 + 16},
|
||||||
|
{"v4 later fragment", serialize(t, ip4later, tcp(ip4later), payload), 20 + 16},
|
||||||
|
{"v4 icmp", serialize(t, ip4icmp, &layers.ICMPv4{TypeCode: layers.CreateICMPv4TypeCode(8, 0), Id: 1, Seq: 1}, payload), 20 + 2},
|
||||||
|
{"v4 header length below the minimum", badIHL, 20 + 16},
|
||||||
|
{"v4 total length below the header length", shortTotalLen, 20 + 16},
|
||||||
|
{"v4 truncated below its total length", truncate(serialize(t, ip4tcp, tcp(ip4tcp), payload), 30), -1},
|
||||||
|
{"v4 tcp header cut short", cutTCP, 20 + 16},
|
||||||
|
{"v4 udp header cut short", cutUDP, -1},
|
||||||
|
{"v6 fragment", withExtensionHeader(serialize(t, ip6tcp, tcp(ip6tcp), payload), layers.IPProtocolIPv6Fragment, fragment), 48 + 16},
|
||||||
|
{"v6 truncated below its payload length", truncate(serialize(t, ip6tcp, tcp(ip6tcp), payload), 50), -1},
|
||||||
|
{"v6 truncated with a whole transport header still present", cutV6, 40 + 16},
|
||||||
|
{"v6 extension header chain longer than the walk", extChain(9, 0), 112 + 16},
|
||||||
|
{"v6 extension header chain running past the packet", extChain(8, 255), 104 + 16},
|
||||||
|
{"v4 udp length past the end of the datagram", overrun4, 20 + 6},
|
||||||
|
{"v6 udp length past the end of the datagram", overrun6, 40 + 6},
|
||||||
|
{"v4 udp length below a udp header", shortUDPLen, 20 + 6},
|
||||||
|
}
|
||||||
|
for _, tt := range untouched {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
if tt.cksum >= 0 {
|
||||||
|
binary.BigEndian.PutUint16(tt.pkt[tt.cksum:], 0x1234)
|
||||||
|
}
|
||||||
|
want := append([]byte(nil), tt.pkt...)
|
||||||
|
SetTransportChecksum(tt.pkt)
|
||||||
|
assert.Equal(t, want, tt.pkt)
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
t.Run("too short to carry a header", func(t *testing.T) {
|
||||||
|
for _, pkt := range [][]byte{nil, {}, {0x45}, {0x60}} {
|
||||||
|
assert.NotPanics(t, func() { SetTransportChecksum(pkt) })
|
||||||
|
}
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("tcp checksum of zero goes out as zero", func(t *testing.T) {
|
||||||
|
pkt := serialize(t, ip4tcp, tcp(ip4tcp), gopacket.Payload{0, 0})
|
||||||
|
c := binary.BigEndian.Uint16(pkt[36:38])
|
||||||
|
require.NotZero(t, c)
|
||||||
|
// Only udp reserves zero to mean "not computed", so tcp keeps it.
|
||||||
|
binary.BigEndian.PutUint16(pkt[40:42], c)
|
||||||
|
SetTransportChecksum(pkt)
|
||||||
|
assert.Zero(t, binary.BigEndian.Uint16(pkt[36:38]))
|
||||||
|
})
|
||||||
|
|
||||||
|
t.Run("udp checksum of zero goes out as 0xffff", func(t *testing.T) {
|
||||||
|
pkt := serialize(t, ip4udp, udp(ip4udp), gopacket.Payload{0, 0})
|
||||||
|
c := binary.BigEndian.Uint16(pkt[26:28])
|
||||||
|
require.NotZero(t, c)
|
||||||
|
// The one's complement sum is now 0xffff - c; adding c to the payload
|
||||||
|
// makes it 0xffff, whose complement is zero.
|
||||||
|
binary.BigEndian.PutUint16(pkt[28:30], c)
|
||||||
|
SetTransportChecksum(pkt)
|
||||||
|
assert.Equal(t, uint16(0xffff), binary.BigEndian.Uint16(pkt[26:28]))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestFold(t *testing.T) {
|
||||||
|
// 0xffff is the fold's fixed point, so a loop bound one notch tight never
|
||||||
|
// terminates on it.
|
||||||
|
for _, tt := range []struct {
|
||||||
|
in uint32
|
||||||
|
want uint16
|
||||||
|
}{
|
||||||
|
{0, 0},
|
||||||
|
{0xffff, 0xffff},
|
||||||
|
{0x10000, 1},
|
||||||
|
{0x1fffe, 0xffff},
|
||||||
|
{0xffffffff, 0xffff},
|
||||||
|
} {
|
||||||
|
assert.Equal(t, tt.want, fold(tt.in))
|
||||||
|
}
|
||||||
|
}
|
||||||
+38
-9
@@ -2,11 +2,16 @@ package iputil
|
|||||||
|
|
||||||
import (
|
import (
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
|
"errors"
|
||||||
|
|
||||||
"golang.org/x/net/ipv4"
|
"golang.org/x/net/ipv4"
|
||||||
"golang.org/x/net/ipv6"
|
"golang.org/x/net/ipv6"
|
||||||
)
|
)
|
||||||
|
|
||||||
|
// ErrIPv6CouldNotFindPayload is returned when the ipv6 extension header chain is truncated before a terminal
|
||||||
|
// upper layer protocol is reached.
|
||||||
|
var ErrIPv6CouldNotFindPayload = errors.New("could not find payload in ipv6 packet")
|
||||||
|
|
||||||
const (
|
const (
|
||||||
// MaxIPv4RejectPacketSize is the largest IPv4 reject packet:
|
// MaxIPv4RejectPacketSize is the largest IPv4 reject packet:
|
||||||
// - 20 byte ipv4 header
|
// - 20 byte ipv4 header
|
||||||
@@ -22,6 +27,13 @@ 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 {
|
||||||
@@ -199,8 +211,8 @@ func ipv4CreateRejectTCPPacket(packet []byte, out []byte) []byte {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func ipv6CreateRejectPacket(packet []byte, out []byte) []byte {
|
func ipv6CreateRejectPacket(packet []byte, out []byte) []byte {
|
||||||
proto, offset, isFragment := ipv6FindUpperProtocol(packet)
|
proto, offset, isFragment, _, err := IPv6FindUpperProtocol(packet)
|
||||||
if isFragment {
|
if err != nil || isFragment {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
switch proto {
|
switch proto {
|
||||||
@@ -333,40 +345,57 @@ func ipv6CreateRejectTCPPacket(packet []byte, out []byte, offset int) []byte {
|
|||||||
return out
|
return out
|
||||||
}
|
}
|
||||||
|
|
||||||
func ipv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragment bool) {
|
// 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.
|
||||||
|
// Only the RFC 8200 and IANA extension headers below are walked.
|
||||||
|
// Everything else, including Mobility (135), HIP (139), Shim6 (140), experimental 253/254, and real upper layer protocols like SCTP or GRE, is terminal.
|
||||||
|
// 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.
|
||||||
|
// Returns ErrIPv6CouldNotFindPayload if packet is smaller than an ipv6 header, or the chain is truncated, or if more than 8 extension headers are present.
|
||||||
|
func IPv6FindUpperProtocol(packet []byte) (nextHeader uint8, offset int, isFragment bool, anyFragment bool, err error) {
|
||||||
|
const maxIPv6ExtHeaders = 8
|
||||||
|
if len(packet) < ipv6.HeaderLen {
|
||||||
|
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
||||||
|
}
|
||||||
nextHeader = packet[6]
|
nextHeader = packet[6]
|
||||||
offset = ipv6.HeaderLen
|
offset = ipv6.HeaderLen
|
||||||
|
|
||||||
for {
|
for range maxIPv6ExtHeaders {
|
||||||
switch nextHeader {
|
switch nextHeader {
|
||||||
case 0, 43, 60: // Hop-by-Hop, Routing, Destination
|
case 0, 43, 60: // Hop-by-Hop, Routing, Destination
|
||||||
if len(packet) < offset+2 {
|
if len(packet) < offset+2 {
|
||||||
return nextHeader, offset, isFragment
|
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
nextHeader = packet[offset]
|
nextHeader = packet[offset]
|
||||||
offset += (int(packet[offset+1]) + 1) << 3
|
offset += (int(packet[offset+1]) + 1) << 3
|
||||||
|
|
||||||
case 44: // Fragment
|
case 44: // Fragment
|
||||||
if len(packet) < offset+8 {
|
if len(packet) < offset+8 {
|
||||||
return nextHeader, offset, isFragment
|
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
|
anyFragment = true
|
||||||
|
// 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 {
|
||||||
isFragment = true
|
return packet[offset], offset, true, anyFragment, nil
|
||||||
}
|
}
|
||||||
nextHeader = packet[offset]
|
nextHeader = packet[offset]
|
||||||
offset += 8
|
offset += 8
|
||||||
|
|
||||||
case 51: // AH
|
case 51: // AH
|
||||||
if len(packet) < offset+2 {
|
if len(packet) < offset+2 {
|
||||||
return nextHeader, offset, isFragment
|
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
nextHeader = packet[offset]
|
nextHeader = packet[offset]
|
||||||
offset += (int(packet[offset+1]) + 2) << 2
|
offset += (int(packet[offset+1]) + 2) << 2
|
||||||
|
|
||||||
default:
|
default:
|
||||||
return nextHeader, offset, isFragment
|
if offset > len(packet) {
|
||||||
|
// A prior extension header can declare a length that advances offset past the packet, reject this.
|
||||||
|
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
||||||
|
}
|
||||||
|
return nextHeader, offset, isFragment, anyFragment, nil //success!
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
// Fail closed
|
||||||
|
return 0, 0, false, false, ErrIPv6CouldNotFindPayload
|
||||||
}
|
}
|
||||||
|
|
||||||
func CreateICMPEchoResponse(packet, out []byte) []byte {
|
func CreateICMPEchoResponse(packet, out []byte) []byte {
|
||||||
|
|||||||
@@ -1,11 +1,13 @@
|
|||||||
package iputil
|
package iputil
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"bytes"
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
"net"
|
"net"
|
||||||
"testing"
|
"testing"
|
||||||
|
|
||||||
"github.com/stretchr/testify/assert"
|
"github.com/stretchr/testify/assert"
|
||||||
|
"github.com/stretchr/testify/require"
|
||||||
"golang.org/x/net/ipv4"
|
"golang.org/x/net/ipv4"
|
||||||
"golang.org/x/net/ipv6"
|
"golang.org/x/net/ipv6"
|
||||||
)
|
)
|
||||||
@@ -179,6 +181,46 @@ 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
|
||||||
@@ -474,3 +516,75 @@ func TestCreateICMPEchoResponse_IPv6_NotICMPv6(t *testing.T) {
|
|||||||
result := CreateICMPEchoResponse(packet, out)
|
result := CreateICMPEchoResponse(packet, out)
|
||||||
assert.Nil(t, result)
|
assert.Nil(t, result)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func Test_IPv6FindUpperProtocol(t *testing.T) {
|
||||||
|
src := net.ParseIP("fd00::1")
|
||||||
|
dst := net.ParseIP("fd00::2")
|
||||||
|
|
||||||
|
// 8 byte extension/transport stand-ins, first byte is the next header, second is the length field
|
||||||
|
extToTCP := []byte{6, 0, 0, 0, 0, 0, 0, 0} // len 0 -> 8 bytes, next = TCP
|
||||||
|
extToUDP := []byte{17, 0, 0, 0, 0, 0, 0, 0} // len 0 -> 8 bytes, next = UDP
|
||||||
|
extToRouting := []byte{43, 0, 0, 0, 0, 0, 0, 0} // len 0 -> 8 bytes, next = Routing
|
||||||
|
ahToUDP := []byte{17, 0, 0, 0, 0, 0, 0, 0} // AH len 0 -> (0+2)<<2 = 8 bytes, 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
|
||||||
|
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 {
|
||||||
|
name string
|
||||||
|
nextHeader uint8
|
||||||
|
payload []byte
|
||||||
|
wantProto uint8
|
||||||
|
wantOffset int
|
||||||
|
wantFragment bool
|
||||||
|
wantAnyFrag bool
|
||||||
|
wantErr error
|
||||||
|
}{
|
||||||
|
{"plain udp", 17, transport, 17, ipv6.HeaderLen, false, false, nil},
|
||||||
|
{"hop-by-hop then tcp", 0, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
|
{"routing then tcp", 43, append(extToTCP, transport...), 6, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
|
{"destination then udp", 60, append(extToUDP, transport...), 17, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
|
{"hop-by-hop, routing, then tcp", 0, append(append(extToRouting, extToTCP...), transport...), 6, ipv6.HeaderLen + 16, false, false, nil},
|
||||||
|
{"ah then udp", 51, append(ahToUDP, transport...), 17, ipv6.HeaderLen + 8, false, false, nil},
|
||||||
|
{"first fragment walks to transport", 44, append(firstFragToUDP, transport...), 17, ipv6.HeaderLen + 8, false, true, nil},
|
||||||
|
{"non-first fragment stops", 44, append(nonFirstFrag, transport...), 17, ipv6.HeaderLen, true, true, nil},
|
||||||
|
{"unknown protocol is terminal", 132, transport, 132, ipv6.HeaderLen, false, false, nil}, // SCTP
|
||||||
|
{"truncated extension header", 0, nil, 0, 0, false, false, ErrIPv6CouldNotFindPayload},
|
||||||
|
// 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},
|
||||||
|
{"budget exhausted fails closed", 0, budgetChain, 0, 0, false, false, ErrIPv6CouldNotFindPayload},
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, tt := range tests {
|
||||||
|
t.Run(tt.name, func(t *testing.T) {
|
||||||
|
packet := makeIPv6Packet(src, dst, tt.nextHeader, tt.payload)
|
||||||
|
proto, offset, isFragment, anyFragment, err := IPv6FindUpperProtocol(packet)
|
||||||
|
if tt.wantErr != nil {
|
||||||
|
require.ErrorIs(t, err, tt.wantErr)
|
||||||
|
} else {
|
||||||
|
require.NoError(t, err)
|
||||||
|
}
|
||||||
|
assert.Equal(t, tt.wantProto, proto)
|
||||||
|
assert.Equal(t, tt.wantOffset, offset)
|
||||||
|
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
|
||||||
|
t.Run("shorter than ipv6 header", func(t *testing.T) {
|
||||||
|
_, _, _, _, err := IPv6FindUpperProtocol(make([]byte, 6))
|
||||||
|
assert.ErrorIs(t, err, ErrIPv6CouldNotFindPayload)
|
||||||
|
})
|
||||||
|
}
|
||||||
+70
-6
@@ -15,10 +15,12 @@ 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"
|
||||||
)
|
)
|
||||||
@@ -34,12 +36,18 @@ 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
|
||||||
@@ -74,6 +82,8 @@ 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
|
||||||
|
|
||||||
@@ -104,15 +114,19 @@ 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", 64)),
|
queryChan: make(chan netip.Addr, c.GetUint32("handshakes.query_buffer", 1024)),
|
||||||
|
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 {
|
||||||
return localAddrs(h.l, al)
|
addrs, err := nicfinder.Find(ctx, h.l, al)
|
||||||
|
h.logLocalAddrsErr(err)
|
||||||
|
return addrs
|
||||||
}
|
}
|
||||||
|
|
||||||
lighthouses := make([]netip.Addr, 0)
|
lighthouses := make([]netip.Addr, 0)
|
||||||
@@ -345,7 +359,13 @@ func (lh *LightHouse) reload(c *config.C, initial bool) error {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if initial || c.HasChanged("relay.relays") {
|
// am_relay decides whether relay.relays applies to us at all
|
||||||
|
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
|
||||||
@@ -370,6 +390,11 @@ 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
|
||||||
@@ -502,14 +527,19 @@ func (lh *LightHouse) Query(vpnAddr netip.Addr) *RemoteList {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// QueryServer is asynchronous so no reply should be expected
|
// QueryServer is asynchronous and non-blocking, 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
|
||||||
}
|
}
|
||||||
|
|
||||||
lh.queryChan <- vpnAddr
|
select {
|
||||||
|
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 {
|
||||||
@@ -913,6 +943,26 @@ func (lh *LightHouse) TriggerUpdate() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// logLocalAddrsErr reports a localAddrs failure at Warn the first time it is seen and at Debug while
|
||||||
|
// it persists unchanged, so a permanent failure does not warn on every update forever.
|
||||||
|
func (lh *LightHouse) logLocalAddrsErr(err error) {
|
||||||
|
if err == nil {
|
||||||
|
lh.lastLocalAddrsErr.Store(nil)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
msg := err.Error()
|
||||||
|
prev := lh.lastLocalAddrsErr.Swap(&msg)
|
||||||
|
if prev != nil && *prev == msg {
|
||||||
|
if lh.l.Enabled(context.Background(), slog.LevelDebug) {
|
||||||
|
lh.l.Debug("Failed to collect local addresses to advertise", "error", err)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
lh.l.Warn("Failed to collect local addresses to advertise", "error", err)
|
||||||
|
}
|
||||||
|
|
||||||
func (lh *LightHouse) SendUpdate() {
|
func (lh *LightHouse) SendUpdate() {
|
||||||
var v4 []*V4AddrPort
|
var v4 []*V4AddrPort
|
||||||
var v6 []*V6AddrPort
|
var v6 []*V6AddrPort
|
||||||
@@ -1158,6 +1208,17 @@ 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
|
||||||
@@ -1194,10 +1255,13 @@ 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
|
||||||
|
|||||||
+314
-55
@@ -1,16 +1,21 @@
|
|||||||
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"
|
||||||
@@ -27,15 +32,27 @@ 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")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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)
|
||||||
@@ -55,12 +72,7 @@ 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")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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)
|
||||||
@@ -90,12 +102,7 @@ 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")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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)
|
||||||
@@ -195,12 +202,7 @@ 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")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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)
|
||||||
@@ -280,12 +282,7 @@ 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")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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)
|
||||||
@@ -315,12 +312,7 @@ func TestLighthouse_reloadStaticHostMap(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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)
|
||||||
@@ -429,7 +421,9 @@ 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{}))
|
||||||
}
|
}
|
||||||
|
|
||||||
func newLHHostRequest(fromAddr netip.AddrPort, myVpnIp, queryVpnIp netip.Addr, lhh *LightHouseHandler) testLhReply {
|
// sendLHHostRequest delivers a HostQuery to lhh and hands back the writer that
|
||||||
|
// 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{},
|
||||||
@@ -447,12 +441,59 @@ func newLHHostRequest(fromAddr netip.AddrPort, myVpnIp, queryVpnIp netip.Addr, l
|
|||||||
panic(err)
|
panic(err)
|
||||||
}
|
}
|
||||||
|
|
||||||
filter := NebulaMeta_HostQueryReply
|
w := &testEncWriter{metaFilter: filter}
|
||||||
w := &testEncWriter{
|
|
||||||
metaFilter: &filter,
|
|
||||||
}
|
|
||||||
lhh.HandleRequest(fromAddr, []netip.Addr{myVpnIp}, b, w)
|
lhh.HandleRequest(fromAddr, []netip.Addr{myVpnIp}, b, w)
|
||||||
return w.lastReply
|
return w
|
||||||
|
}
|
||||||
|
|
||||||
|
func newLHHostRequest(fromAddr netip.AddrPort, myVpnIp, queryVpnIp netip.Addr, lhh *LightHouseHandler) testLhReply {
|
||||||
|
filter := NebulaMeta_HostQueryReply
|
||||||
|
return sendLHHostRequest(fromAddr, myVpnIp, queryVpnIp, lhh, &filter).lastReply
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLighthouse_IgnoresHostQueryForItself(t *testing.T) {
|
||||||
|
// 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) {
|
||||||
@@ -498,7 +539,7 @@ type testEncWriter struct {
|
|||||||
protocolVersion cert.Version
|
protocolVersion cert.Version
|
||||||
}
|
}
|
||||||
|
|
||||||
func (tw *testEncWriter) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool) {
|
func (tw *testEncWriter) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool, q int) {
|
||||||
}
|
}
|
||||||
func (tw *testEncWriter) Handshake(vpnIp netip.Addr) {
|
func (tw *testEncWriter) Handshake(vpnIp netip.Addr) {
|
||||||
}
|
}
|
||||||
@@ -642,12 +683,7 @@ 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")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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{}
|
||||||
@@ -708,12 +744,7 @@ func TestLighthouse_DeletesWork(t *testing.T) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
|
||||||
nt := new(bart.Lite)
|
cs := testCertState(myVpnNet)
|
||||||
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{}
|
||||||
@@ -738,3 +769,231 @@ 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)
|
||||||
|
}
|
||||||
@@ -0,0 +1,31 @@
|
|||||||
|
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
|
||||||
|
}
|
||||||
@@ -0,0 +1,106 @@
|
|||||||
|
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,11 +6,15 @@ 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/overlay"
|
"github.com/slackhq/nebula/overlay"
|
||||||
"github.com/slackhq/nebula/sshd"
|
"github.com/slackhq/nebula/sshd"
|
||||||
"github.com/slackhq/nebula/udp"
|
"github.com/slackhq/nebula/udp"
|
||||||
@@ -20,11 +24,20 @@ import (
|
|||||||
|
|
||||||
type m = map[string]any
|
type m = map[string]any
|
||||||
|
|
||||||
|
// maxRoutines caps routines below the RejectHeadroom nonce gap so concurrent senders can't race the counter past wrap.
|
||||||
|
const maxRoutines = 1 << 16
|
||||||
|
|
||||||
|
// The reject headroom must exceed every sender that can be mid-reservation at once, about two per routine.
|
||||||
|
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())
|
||||||
// Automatically cancel the context if Main returns an error, to signal all created goroutines to quit.
|
// The goroutines started below stop only when this context does, and only a caller holding the
|
||||||
|
// Control can arrange that. Cancel whenever we are not handing one back, which covers an error
|
||||||
|
// and a config test alike: a config test used to leave the lighthouse query worker, and a
|
||||||
|
// hostname resolver per dns named static host, running for the life of the process.
|
||||||
defer func() {
|
defer func() {
|
||||||
if reterr != nil {
|
if retcon == nil {
|
||||||
cancel()
|
cancel()
|
||||||
}
|
}
|
||||||
}()
|
}()
|
||||||
@@ -33,6 +46,9 @@ 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)
|
||||||
@@ -81,9 +97,6 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
if routines < 1 {
|
if routines < 1 {
|
||||||
routines = 1
|
routines = 1
|
||||||
}
|
}
|
||||||
if routines > 1 {
|
|
||||||
l.Info("Using multiple routines", "routines", routines)
|
|
||||||
}
|
|
||||||
} else {
|
} else {
|
||||||
// deprecated and undocumented
|
// deprecated and undocumented
|
||||||
tunQueues := c.GetInt("tun.routines", 1)
|
tunQueues := c.GetInt("tun.routines", 1)
|
||||||
@@ -93,6 +106,12 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
l.Warn("Setting tun.routines and listen.routines is deprecated. Use `routines` instead", "routines", routines)
|
l.Warn("Setting tun.routines and listen.routines is deprecated. Use `routines` instead", "routines", routines)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if routines > maxRoutines {
|
||||||
|
l.Warn("Using multiple routines", "routines", maxRoutines, "clamped", true, "requestedRoutines", routines)
|
||||||
|
routines = maxRoutines
|
||||||
|
} else if routines > 1 {
|
||||||
|
l.Info("Using multiple routines", "routines", routines)
|
||||||
|
}
|
||||||
|
|
||||||
// EXPERIMENTAL
|
// EXPERIMENTAL
|
||||||
// Intentionally not documented yet while we do more testing and determine
|
// Intentionally not documented yet while we do more testing and determine
|
||||||
@@ -160,8 +179,21 @@ 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++ {
|
||||||
l.Info("listening", "addr", netip.AddrPortFrom(listenHost, uint16(port)))
|
listen := netip.AddrPortFrom(listenHost, uint16(port))
|
||||||
udpServer, err := udp.NewListener(l, listenHost, port, routines > 1, c.GetInt("listen.batch", 64))
|
l.Info("listening", "addr", listen)
|
||||||
|
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)
|
||||||
}
|
}
|
||||||
@@ -200,9 +232,11 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
|||||||
retries: int64(c.GetInt("handshakes.retries", DefaultHandshakeRetries)),
|
retries: int64(c.GetInt("handshakes.retries", DefaultHandshakeRetries)),
|
||||||
triggerBuffer: c.GetInt("handshakes.trigger_buffer", DefaultHandshakeTriggerBuffer),
|
triggerBuffer: c.GetInt("handshakes.trigger_buffer", DefaultHandshakeTriggerBuffer),
|
||||||
messageMetrics: messageMetrics,
|
messageMetrics: messageMetrics,
|
||||||
|
pq: pqHandshakeConfigFrom(c),
|
||||||
}
|
}
|
||||||
|
|
||||||
handshakeManager := NewHandshakeManager(l, hostMap, lightHouse, udpConns[0], handshakeConfig)
|
handshakeManager := NewHandshakeManager(l, hostMap, lightHouse, udpConns[0], handshakeConfig)
|
||||||
|
c.RegisterReloadCallback(handshakeManager.reloadPQ)
|
||||||
lightHouse.handshakeTrigger = handshakeManager.trigger
|
lightHouse.handshakeTrigger = handshakeManager.trigger
|
||||||
|
|
||||||
ds, err := newDnsServerFromConfig(ctx, l, pki, hostMap, c)
|
ds, err := newDnsServerFromConfig(ctx, l, pki, hostMap, c)
|
||||||
@@ -210,6 +244,37 @@ 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)
|
||||||
|
cpuAffinity := parseCpuAffinity(c, l, routines)
|
||||||
|
if pinThreads && routines > 1 && len(cpuAffinity) == 0 && !configTest {
|
||||||
|
// The operator didn't choose pin CPUs, so pick a default set that
|
||||||
|
// prefers performance cores and doesn't stack co-located instances
|
||||||
|
// 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, l)
|
||||||
|
}
|
||||||
|
|
||||||
ifConfig := &InterfaceConfig{
|
ifConfig := &InterfaceConfig{
|
||||||
HostMap: hostMap,
|
HostMap: hostMap,
|
||||||
Inside: tun,
|
Inside: tun,
|
||||||
@@ -231,10 +296,13 @@ 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,
|
||||||
|
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 {
|
||||||
@@ -253,9 +321,12 @@ 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)
|
stats, err := newStatsServerFromConfig(ctx, l, c, buildVersion, configTest, emitStats)
|
||||||
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)
|
||||||
}
|
}
|
||||||
@@ -264,8 +335,6 @@ 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)
|
||||||
@@ -285,6 +354,70 @@ 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.
|
||||||
|
func parseCpuAffinity(c *config.C, l *slog.Logger, routines 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
|
||||||
|
}
|
||||||
|
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
|
||||||
|
}
|
||||||
|
|
||||||
func moduleVersion() string {
|
func moduleVersion() string {
|
||||||
info, ok := debug.ReadBuildInfo()
|
info, ok := debug.ReadBuildInfo()
|
||||||
if !ok {
|
if !ok {
|
||||||
|
|||||||
+125
@@ -0,0 +1,125 @@
|
|||||||
|
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))
|
||||||
|
|
||||||
|
// 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))
|
||||||
|
|
||||||
|
// a negative entry is out of range on every platform -> disables the override
|
||||||
|
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, -1}), l, 2))
|
||||||
|
|
||||||
|
// a non-integer entry -> disables the override
|
||||||
|
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, "not-a-cpu"}), l, 2))
|
||||||
|
|
||||||
|
// 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))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 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")
|
||||||
|
}
|
||||||
Loaded 100 of 223 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user