Compare commits

..
Author SHA1 Message Date
github-actions[bot] 5ebe61de62 chore: update flake hashes for v2.6.5 from snapshot 2026-08-30 11:36:02 +00:00
142 changed files with 3416 additions and 16667 deletions

No files matched your search

+15 -163
View File
@@ -2,11 +2,6 @@ name: Build
on:
workflow_dispatch:
inputs:
build_only:
description: 'Build and test artifacts without publishing releases, images, or update feeds'
required: true
default: false
type: boolean
gp_branch:
description: 'GlobalProtect-openconnect branch to use for the snapshot release'
required: true
@@ -45,7 +40,7 @@ on:
- v*.*.*
concurrency:
group: ${{ github.workflow }}-${{ github.event_name == 'workflow_dispatch' && (inputs.build_only && github.run_id || 'release') || github.ref }}
group: ${{ github.workflow }}-${{ github.event_name == 'workflow_dispatch' && 'release' || github.ref }}
cancel-in-progress: ${{ github.event_name == 'push' && !startsWith(github.ref, 'refs/tags/') }}
jobs:
@@ -238,13 +233,11 @@ jobs:
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v4
- name: Login to Docker Hub
if: ${{ github.event_name != 'workflow_dispatch' || !inputs.build_only }}
uses: docker/login-action@v4
with:
username: ${{ secrets.DOCKER_HUB_USERNAME }}
password: ${{ secrets.DOCKER_HUB_TOKEN }}
- name: Build and push by digest
if: ${{ github.event_name != 'workflow_dispatch' || !inputs.build_only }}
id: build
uses: docker/build-push-action@v7
with:
@@ -252,37 +245,20 @@ jobs:
file: packaging/docker/alpine/Dockerfile
platforms: ${{ matrix.platform }}
outputs: type=image,name=yuezk/globalprotect-openconnect,push-by-digest=true,name-canonical=true,push=true
- name: Build local image for verification
if: ${{ github.event_name == 'workflow_dispatch' && inputs.build_only }}
uses: docker/build-push-action@v7
with:
context: .
file: packaging/docker/alpine/Dockerfile
platforms: ${{ matrix.platform }}
tags: yuezk/globalprotect-openconnect:build-test
load: true
push: false
- name: Verify CLI tools
env:
IMAGE: yuezk/globalprotect-openconnect
DIGEST: ${{ steps.build.outputs.digest }}
BUILD_ONLY: ${{ github.event_name == 'workflow_dispatch' && inputs.build_only }}
run: |
image_ref="$IMAGE@$DIGEST"
if [[ "$BUILD_ONLY" == "true" ]]; then
image_ref="$IMAGE:build-test"
fi
docker run --rm "$image_ref" --help
docker run --rm --entrypoint gpauth "$image_ref" --help
docker run --rm --entrypoint sh "$image_ref" -lc 'test "$(id -u gp)" = "1000" && test "$SUDO_UID" = "1000"'
docker run --rm "$IMAGE@$DIGEST" --help
docker run --rm --entrypoint gpauth "$IMAGE@$DIGEST" --help
docker run --rm --entrypoint sh "$IMAGE@$DIGEST" -lc 'test "$(id -u gp)" = "1000" && test "$SUDO_UID" = "1000"'
- name: Export digest
if: ${{ github.event_name != 'workflow_dispatch' || !inputs.build_only }}
run: |
mkdir -p /tmp/digests
digest="${{ steps.build.outputs.digest }}"
touch "/tmp/digests/${digest#sha256:}"
- name: Upload digest
if: ${{ github.event_name != 'workflow_dispatch' || !inputs.build_only }}
uses: actions/upload-artifact@v7
with:
name: digests-${{ env.PLATFORM_PAIR }}
@@ -337,14 +313,11 @@ jobs:
cd gpgui-source
tar -czf gpgui.tar.gz gpgui gp
- name: Build gpgui in Docker
env:
GPGUI_LICENSE_SIGNING_KEYS: ${{ vars.GPGUI_LICENSE_SIGNING_KEYS }}
run: |
docker run --rm \
-e COREPACK_INTEGRITY_KEYS=0 \
-e GPGUI_BUILD_VERSION=${{ github.run_number }}.${{ github.run_attempt }} \
-e GPGUI_UPDATE_CHANNEL=${{ github.event_name == 'workflow_dispatch' && 'snapshot' || 'stable' }} \
-e GPGUI_LICENSE_SIGNING_KEYS \
-v $(pwd)/gpgui-source:/workspace yuezk/gpdev:${{ matrix.libc.builder }}
- name: Install gpgui in Docker
run: |
@@ -363,118 +336,6 @@ jobs:
gpgui-source/*.bin.tar.xz
gpgui-source/*.bin.tar.xz.sha256
nix-source:
needs: [build-gpgui]
strategy:
fail-fast: false
matrix:
platform:
- runner: ubuntu-latest
system: x86_64-linux
artifact_arch: amd64
- runner: ubuntu-24.04-arm
system: aarch64-linux
artifact_arch: ubuntu-24.04-arm
runs-on: ${{ matrix.platform.runner }}
name: nix-source (${{ matrix.platform.system }})
env:
NIX_SYSTEM: ${{ matrix.platform.system }}
NIXPKGS: locked
steps:
- name: Checkout source and dependencies
uses: actions/checkout@v6
with:
token: ${{ secrets.GH_PAT }}
ref: ${{ github.event_name == 'workflow_dispatch' && inputs.gp_branch || github.ref }}
submodules: recursive
path: gp
- name: Download current GUI artifact
uses: actions/download-artifact@v8
with:
name: artifact-gpgui-${{ matrix.platform.artifact_arch }}
path: nix-artifacts/gui
- name: Install Nix
uses: cachix/install-nix-action@v31
- name: Configure current source and GUI inputs
run: |
echo "GP_SOURCE=$PWD/gp" >> "$GITHUB_ENV"
gui_archive=$(find "$PWD/nix-artifacts/gui" -name '*.bin.tar.xz' -type f)
test -f "$gui_archive"
echo "GP_GUI_ARCHIVE=$gui_archive" >> "$GITHUB_ENV"
- name: Build source package
run: |
nix build --impure --file gp/nix/ci.nix source \
--extra-experimental-features "nix-command flakes" --print-build-logs
bash gp/scripts/tests/nix-desktop-authorization.sh result
- name: Test source runtime in NixOS
if: matrix.platform.system == 'x86_64-linux'
run: |
nix build --impure --file gp/nix/ci.nix runtime-source \
--extra-experimental-features "nix-command flakes" --print-build-logs
nix-prebuilt:
needs: [build-gp, build-gpgui]
strategy:
fail-fast: false
matrix:
platform:
- runner: ubuntu-latest
system: x86_64-linux
artifact_arch: amd64
- runner: ubuntu-24.04-arm
system: aarch64-linux
artifact_arch: ubuntu-24.04-arm
nixpkgs: [locked, nixos-25.11, nixos-26.05, nixpkgs-unstable]
runs-on: ${{ matrix.platform.runner }}
name: nix-prebuilt (${{ matrix.platform.system }}, ${{ matrix.nixpkgs }})
env:
NIX_SYSTEM: ${{ matrix.platform.system }}
NIXPKGS: ${{ matrix.nixpkgs }}
steps:
- name: Checkout packaging and tests
uses: actions/checkout@v6
with:
token: ${{ secrets.GH_PAT }}
ref: ${{ github.event_name == 'workflow_dispatch' && inputs.gp_branch || github.ref }}
submodules: recursive
path: gp
- name: Download current Linux binary artifact
uses: actions/download-artifact@v8
with:
name: artifact-gp-binary-${{ matrix.platform.artifact_arch }}
path: nix-artifacts/binaries
- name: Download current GUI artifact
uses: actions/download-artifact@v8
with:
name: artifact-gpgui-${{ matrix.platform.artifact_arch }}
path: nix-artifacts/gui
- name: Install Nix
uses: cachix/install-nix-action@v31
- name: Configure current artifact inputs
run: |
echo "GP_SOURCE=$PWD/gp" >> "$GITHUB_ENV"
binary_archive=$(find "$PWD/nix-artifacts/binaries" -name '*.bin.tar.xz' -type f)
gui_archive=$(find "$PWD/nix-artifacts/gui" -name '*.bin.tar.xz' -type f)
test -f "$binary_archive"
test -f "$gui_archive"
echo "GP_BINARY_ARCHIVE=$binary_archive" >> "$GITHUB_ENV"
echo "GP_GUI_ARCHIVE=$gui_archive" >> "$GITHUB_ENV"
- name: Build package through host NixOS module
run: |
nix build --impure --file gp/nix/ci.nix module \
--extra-experimental-features "nix-command flakes" --print-build-logs
bash gp/scripts/tests/nix-desktop-authorization.sh result
- name: Build standalone prebuilt package
if: matrix.nixpkgs == 'locked'
run: |
nix build --impure --file gp/nix/ci.nix prebuilt \
--extra-experimental-features "nix-command flakes" --print-build-logs
- name: Test prebuilt runtime in NixOS
if: matrix.nixpkgs == 'locked' && matrix.platform.system == 'x86_64-linux'
run: |
nix build --impure --file gp/nix/ci.nix runtime-prebuilt \
--extra-experimental-features "nix-command flakes" --print-build-logs
trigger-gpgui-macos:
if: ${{ startsWith(github.ref, 'refs/tags/') || (github.event_name == 'workflow_dispatch' && inputs.build_macos) }}
permissions:
@@ -496,7 +357,6 @@ jobs:
GPGUI_REF: ${{ github.event_name == 'workflow_dispatch' && inputs.gpgui_branch || github.ref_name }}
BUILD_VERSION: ${{ github.run_number }}.${{ github.run_attempt }}
REQUEST_ID: ${{ github.run_id }}.${{ github.run_attempt }}.macos
BUILD_ONLY: ${{ github.event_name == 'workflow_dispatch' && inputs.build_only }}
run: |
set -euo pipefail
@@ -524,7 +384,6 @@ jobs:
--arg release_tag "$RELEASE_TAG" \
--arg gp_ref "$gp_sha" \
--arg gpgui_ref "$gpgui_sha" \
--argjson build_only "$BUILD_ONLY" \
'{
ref: $workflow_ref,
inputs: {
@@ -533,8 +392,7 @@ jobs:
channel: $channel,
release_tag: $release_tag,
gp_ref: $gp_ref,
gpgui_ref: $gpgui_ref,
build_only: $build_only
gpgui_ref: $gpgui_ref
}
}' | gh api --method POST \
repos/yuezk/gpgui/actions/workflows/release-macos.yaml/dispatches \
@@ -710,7 +568,6 @@ jobs:
set -eu
export GPGUI_BUILD_VERSION=${{ github.run_number }}.${{ github.run_attempt }}
export GPGUI_UPDATE_CHANNEL=${{ github.event_name == 'workflow_dispatch' && 'snapshot' || 'stable' }}
export GPGUI_LICENSE_SIGNING_KEYS='${{ vars.GPGUI_LICENSE_SIGNING_KEYS }}'
cd "${{ matrix.workspace }}/gp"
cargo build --release --workspace
@@ -734,23 +591,22 @@ jobs:
arch: ${{ matrix.arch }}
usesh: true
prepare: |
set -eu
pkg_add -u -I
pkg_add -I \
pkg_add -z \
git \
rust \
libiconv \
gettext-tools \
autoconf%2.72 \
automake%1.17 \
autoconf-2.72 \
automake-1.17 \
libtool \
patch \
gmake \
pkgconf \
libxml \
gnutls \
p11-kit \
nettle \
gmp \
lz4 \
dbus \
gnome-keyring \
polkit \
webkitgtk41 \
@@ -767,7 +623,6 @@ jobs:
export AUTOMAKE_VERSION=1.17
export GPGUI_BUILD_VERSION=${{ github.run_number }}.${{ github.run_attempt }}
export GPGUI_UPDATE_CHANNEL=${{ github.event_name == 'workflow_dispatch' && 'snapshot' || 'stable' }}
export GPGUI_LICENSE_SIGNING_KEYS='${{ vars.GPGUI_LICENSE_SIGNING_KEYS }}'
cd "${{ matrix.workspace }}/gp"
cargo build --release --workspace
@@ -792,7 +647,7 @@ jobs:
${{ matrix.workspace }}/gp/.build/${{ matrix.artifact_dir }}/artifacts/*
gh-release:
if: ${{ always() && ((github.event_name == 'workflow_dispatch' && !inputs.build_only) || startsWith(github.ref, 'refs/tags/')) }}
if: ${{ always() && (github.event_name == 'workflow_dispatch' || startsWith(github.ref, 'refs/tags/')) }}
runs-on: ubuntu-latest
permissions:
actions: read
@@ -801,8 +656,6 @@ jobs:
attestations: write
artifact-metadata: write
needs:
- nix-source
- nix-prebuilt
- tarball
- tarball-offline
- build-gp
@@ -833,7 +686,7 @@ jobs:
result = data["result"]
if result in {"failure", "cancelled"}:
failed.append(f"{name}: {result}")
elif name in {"build-gp", "build-docker-image", "nix-prebuilt"} and result == "skipped" and is_tag:
elif name in {"build-gp", "build-docker-image"} and result == "skipped" and is_tag:
continue
elif name in {"build-gpgui-frontend", "build-bsd"} and result == "skipped" and not bsd_matrix_enabled:
continue
@@ -915,7 +768,6 @@ jobs:
env:
GH_TOKEN: ${{ secrets.GPGUI_ACTIONS_TOKEN }}
PUBLIC_RELEASE_RESULT: ${{ needs.gh-release.result }}
BUILD_ONLY: ${{ github.event_name == 'workflow_dispatch' && inputs.build_only }}
PRIVATE_RUN_ID: ${{ needs.trigger-gpgui-macos.outputs.run_id }}
PRIVATE_RUN_URL: ${{ needs.trigger-gpgui-macos.outputs.run_url }}
run: |
@@ -925,7 +777,7 @@ jobs:
echo "The private macOS workflow was not started" >&2
exit 1
fi
if [[ "$BUILD_ONLY" != "true" && "$PUBLIC_RELEASE_RESULT" != "success" ]]; then
if [[ "$PUBLIC_RELEASE_RESULT" != "success" ]]; then
gh api --method POST \
"repos/yuezk/gpgui/actions/runs/$PRIVATE_RUN_ID/cancel" >/dev/null || true
echo "The public release failed; cancelled $PRIVATE_RUN_URL" >&2
@@ -955,7 +807,7 @@ jobs:
publish-docker-image:
needs:
- build-docker-image
if: ${{ (github.event_name == 'workflow_dispatch' && !inputs.build_only) || startsWith(github.ref, 'refs/tags/') }}
if: ${{ github.event_name == 'workflow_dispatch' || startsWith(github.ref, 'refs/tags/') }}
runs-on: ubuntu-latest
steps:
- name: Download digests
+1 -1
View File
@@ -19,7 +19,7 @@ on:
description: 'Rust version to use'
type: "string"
required: true
default: "1.91"
default: "1.89"
jobs:
check:
runs-on: ubuntu-latest
+22 -42
View File
@@ -24,11 +24,6 @@ jobs:
- name: Install Nix
uses: cachix/install-nix-action@v31
- name: Update Nixpkgs lock
run: |
nix flake update nixpkgs \
--extra-experimental-features "nix-command flakes"
- name: Update flake hashes
env:
RELEASE_VERSION: ${{ inputs.version }}
@@ -44,9 +39,7 @@ jobs:
uses: actions/upload-artifact@v7
with:
name: updated-flake
path: |
flake.nix
flake.lock
path: flake.nix
if-no-files-found: error
validate-nix-prebuilt:
@@ -55,22 +48,22 @@ jobs:
strategy:
fail-fast: false
matrix:
runner:
- ubuntu-latest
- ubuntu-24.04-arm
nixpkgs:
- locked
- nixos-25.11
- nixos-26.05
- nixpkgs-unstable
exclude:
include:
- runner: ubuntu-latest
nixpkgs: nixos-25.11
- runner: ubuntu-latest
nixpkgs: nixos-26.05
- runner: ubuntu-24.04-arm
nixpkgs: locked
nixpkgs: nixos-25.11
- runner: ubuntu-24.04-arm
nixpkgs: nixos-26.05
name: validate-nix-prebuilt (${{ matrix.nixpkgs }}, ${{ matrix.runner }})
runs-on: ${{ matrix.runner }}
steps:
- name: Checkout GlobalProtect-openconnect
uses: actions/checkout@v6
with:
submodules: recursive
- name: Download updated flake
uses: actions/download-artifact@v8
@@ -82,19 +75,11 @@ jobs:
uses: cachix/install-nix-action@v31
- name: Build prebuilt Nix package
env:
NIXPKGS: ${{ matrix.nixpkgs }}
run: |
if [[ "$NIXPKGS" == "locked" ]]; then
nix build .#prebuilt \
--extra-experimental-features "nix-command flakes" \
--print-build-logs
else
nix build .#prebuilt \
--override-input nixpkgs "github:NixOS/nixpkgs/$NIXPKGS" \
--extra-experimental-features "nix-command flakes" \
--print-build-logs
fi
nix build .#prebuilt \
--override-input nixpkgs "github:NixOS/nixpkgs/${{ matrix.nixpkgs }}" \
--extra-experimental-features "nix-command flakes" \
--print-build-logs
- name: Inspect prebuilt Nix package
run: |
@@ -104,19 +89,14 @@ jobs:
test -x result/bin/gpgui-helper
test -x result/bin/gpgui
test ! -L result/bin/gpservice
test -x result/libexec/gpclient/gp-vpnc-script-installer
test -x result/libexec/gpclient/gp-hip-script-installer
result/bin/gpclient --version
result/bin/gpservice --version
result/bin/gpauth --version
head -n1 result/bin/gpclient | grep '^#!'
head -n1 result/bin/gpservice | grep '^#!'
grep -q '/run/wrappers/bin/pkexec' result/bin/gpclient
grep -q 'gpservice_public=.*/bin/gpservice' result/bin/gpclient
grep -q 'exec .*/bin/gpservice' result/bin/gpservice
! grep -q '@gpservice_public@\|@gpservice_fhs@\|\$out/bin/gpservice' result/bin/gpclient result/bin/gpservice
if grep -R '/usr/bin/gp' result/share; then
echo "Desktop assets contain paths outside the Nix package" >&2
exit 1
fi
- name: Verify desktop authorization runs on the host
run: bash scripts/tests/nix-desktop-authorization.sh result
! grep -R '/usr/bin/gp' result/share
open-pull-request:
needs:
+2 -1
View File
@@ -1,5 +1,4 @@
.idea
.DS_Store
/target
.pnpm-store
.env
@@ -16,3 +15,5 @@ gen
# Nix files
result
.DS_Store
Generated
+599 -684
View File
File diff suppressed because it is too large. Load diff
+1 -7
View File
@@ -10,7 +10,7 @@ members = [
]
[workspace.package]
rust-version = "1.91"
rust-version = "1.89"
version = "2.6.5"
authors = ["Kevin Yue <[email protected]>"]
homepage = "https://github.com/yuezk/GlobalProtect-openconnect"
@@ -67,12 +67,6 @@ tauri = { version = "2" }
specta = "=2.0.0-rc.20"
proptest = "1"
[patch.crates-io]
# Restore BSD GTK resize hit testing until https://github.com/tauri-apps/tao/pull/1356 is released.
tao = { git = "https://github.com/yuezk/tao", rev = "1452ae7a42c9f134296ba199f91f514fc9077f61" }
# Use one macro source for Tao and Wry so Cargo can vendor the workspace.
tao-macros = { git = "https://github.com/yuezk/tao", rev = "1452ae7a42c9f134296ba199f91f514fc9077f61" }
[profile.release]
opt-level = 'z' # Optimize for size
lto = true # Enable link-time optimization
+4 -25
View File
@@ -4,7 +4,7 @@ SHELL := /bin/sh
INCLUDE_GUI ?= 0
CARGO ?= cargo
DISABLE_RUST_TOOLCHAIN ?= 0
RUST_VERSION ?= 1.91
RUST_VERSION ?= 1.89
IGNORE_RUST_VERSION ?= 0
VERSION = $(shell grep '^version' Cargo.toml | head -1 | sed 's/version *= *"\(.*\)"/\1/')
@@ -145,7 +145,6 @@ install:
install -Dm755 target/release/gpclient $(DESTDIR)/usr/bin/gpclient
install -Dm755 target/release/gpauth $(DESTDIR)/usr/bin/gpauth
install -Dm755 target/release/gpservice $(DESTDIR)/usr/bin/gpservice
install -Dm755 target/release/gp-hip-script-installer $(DESTDIR)/usr/libexec/gpclient/gp-hip-script-installer
install -Dm755 target/release/gp-vpnc-script-installer $(DESTDIR)/usr/libexec/gpclient/gp-vpnc-script-installer
# Install the GUI components if BUILD_GUI_HELPER is set to 1
@@ -158,6 +157,7 @@ install:
fi
install -Dm755 packaging/files/usr/libexec/gpclient/vpnc-script $(DESTDIR)/usr/libexec/gpclient/vpnc-script
install -Dm755 packaging/files/usr/libexec/gpclient/hipreport.sh $(DESTDIR)/usr/libexec/gpclient/hipreport.sh
# Install the disconnect hooks
install -Dm755 packaging/files/usr/lib/NetworkManager/dispatcher.d/pre-down.d/gpclient.down $(DESTDIR)/usr/lib/NetworkManager/dispatcher.d/pre-down.d/gpclient.down
@@ -169,12 +169,6 @@ install:
install -Dm644 packaging/files/usr/share/icons/hicolor/128x128/apps/gpgui.png $(DESTDIR)/usr/share/icons/hicolor/128x128/apps/gpgui.png
install -Dm644 packaging/files/usr/share/icons/hicolor/256x256/apps/gpgui.png $(DESTDIR)/usr/share/icons/hicolor/256x256/apps/gpgui.png
install -Dm644 packaging/files/usr/share/icons/hicolor/256x256@2/apps/gpgui.png $(DESTDIR)/usr/share/icons/hicolor/256x256@2/apps/gpgui.png
install -Dm644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connected-symbolic.svg $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connected-symbolic.svg
install -Dm644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-disconnected-symbolic.svg $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-disconnected-symbolic.svg
install -Dm644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-1-symbolic.svg $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-1-symbolic.svg
install -Dm644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-2-symbolic.svg $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-2-symbolic.svg
install -Dm644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-3-symbolic.svg $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-3-symbolic.svg
install -Dm644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-4-symbolic.svg $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-4-symbolic.svg
install -Dm644 packaging/files/usr/share/polkit-1/actions/com.yuezk.gpgui.policy $(DESTDIR)/usr/share/polkit-1/actions/com.yuezk.gpgui.policy
install-bsd:
@@ -194,9 +188,9 @@ install-bsd:
fi
install -d $(DESTDIR)$(PREFIX)/libexec/gpclient
install -m 755 target/release/gp-hip-script-installer $(DESTDIR)$(PREFIX)/libexec/gpclient/gp-hip-script-installer
install -m 755 target/release/gp-vpnc-script-installer $(DESTDIR)$(PREFIX)/libexec/gpclient/gp-vpnc-script-installer
install -m 755 packaging/files/usr/libexec/gpclient/vpnc-script $(DESTDIR)$(PREFIX)/libexec/gpclient/vpnc-script
install -m 755 packaging/files/usr/libexec/gpclient/hipreport.sh $(DESTDIR)$(PREFIX)/libexec/gpclient/hipreport.sh
install -d $(DESTDIR)$(PREFIX)/share/applications
install -m 644 packaging/bsd/gpgui.desktop $(DESTDIR)$(PREFIX)/share/applications/gpgui.desktop
@@ -205,18 +199,11 @@ install-bsd:
install -d $(DESTDIR)$(PREFIX)/share/icons/hicolor/128x128/apps
install -d $(DESTDIR)$(PREFIX)/share/icons/hicolor/256x256/apps
install -d $(DESTDIR)$(PREFIX)/share/icons/hicolor/256x256@2/apps
install -d $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/status
install -m 644 packaging/files/usr/share/icons/hicolor/scalable/apps/gpgui.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/apps/gpgui.svg
install -m 644 packaging/files/usr/share/icons/hicolor/32x32/apps/gpgui.png $(DESTDIR)$(PREFIX)/share/icons/hicolor/32x32/apps/gpgui.png
install -m 644 packaging/files/usr/share/icons/hicolor/128x128/apps/gpgui.png $(DESTDIR)$(PREFIX)/share/icons/hicolor/128x128/apps/gpgui.png
install -m 644 packaging/files/usr/share/icons/hicolor/256x256/apps/gpgui.png $(DESTDIR)$(PREFIX)/share/icons/hicolor/256x256/apps/gpgui.png
install -m 644 packaging/files/usr/share/icons/hicolor/256x256@2/apps/gpgui.png $(DESTDIR)$(PREFIX)/share/icons/hicolor/256x256@2/apps/gpgui.png
install -m 644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connected-symbolic.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/status/gpgui-connected-symbolic.svg
install -m 644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-disconnected-symbolic.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/status/gpgui-disconnected-symbolic.svg
install -m 644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-1-symbolic.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/status/gpgui-connecting-1-symbolic.svg
install -m 644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-2-symbolic.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/status/gpgui-connecting-2-symbolic.svg
install -m 644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-3-symbolic.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/status/gpgui-connecting-3-symbolic.svg
install -m 644 packaging/files/usr/share/icons/hicolor/scalable/status/gpgui-connecting-4-symbolic.svg $(DESTDIR)$(PREFIX)/share/icons/hicolor/scalable/status/gpgui-connecting-4-symbolic.svg
install -d $(DESTDIR)$(PREFIX)/share/polkit-1/actions
install -m 644 packaging/bsd/com.yuezk.gpgui.policy $(DESTDIR)$(PREFIX)/share/polkit-1/actions/com.yuezk.gpgui.policy
@@ -272,7 +259,6 @@ package-openbsd: clean-bsd-package
comment=$$(cat .build/openbsd/+COMMENT); \
openbsd_arch=$$(uname -m | sed 's/x86_64/amd64/'); \
gnome_keyring_pkg=$$(pkg_info -e 'gnome-keyring-*' | sed 's/^inst://' | head -n 1); \
dbus_pkg=$$(pkg_info -e 'dbus-*' | sed 's/^inst://' | head -n 1); \
polkit_pkg=$$(pkg_info -e 'polkit-*' | sed 's/^inst://' | head -n 1); \
webkitgtk_pkg=$$(pkg_info -e 'webkitgtk41-*' | sed 's/^inst://' | head -n 1); \
xdg_utils_pkg=$$(pkg_info -e 'xdg-utils-*' | sed 's/^inst://' | head -n 1); \
@@ -283,7 +269,6 @@ package-openbsd: clean-bsd-package
-f .build/openbsd/PLIST \
-p $(PREFIX) \
-P x11/gnome/keyring:gnome-keyring-*:$$gnome_keyring_pkg \
-P x11/dbus:dbus-*:$$dbus_pkg \
-P sysutils/polkit:polkit-*:$$polkit_pkg \
-P www/webkitgtk4,webkitgtk41:webkitgtk41-*:$$webkitgtk_pkg \
-P devel/xdg-utils:xdg-utils-*:$$xdg_utils_pkg \
@@ -296,11 +281,11 @@ uninstall:
rm -f $(DESTDIR)/usr/bin/gpclient
rm -f $(DESTDIR)/usr/bin/gpauth
rm -f $(DESTDIR)/usr/bin/gpservice
rm -f $(DESTDIR)/usr/libexec/gpclient/gp-hip-script-installer
rm -f $(DESTDIR)/usr/bin/gpgui-helper
rm -f $(DESTDIR)/usr/bin/gpgui
rm -f $(DESTDIR)/usr/libexec/gpclient/vpnc-script
rm -f $(DESTDIR)/usr/libexec/gpclient/hipreport.sh
rm -f $(DESTDIR)/usr/libexec/gpclient/gp-vpnc-script-installer
rm -f $(DESTDIR)/usr/lib/NetworkManager/dispatcher.d/pre-down.d/gpclient.down
@@ -312,12 +297,6 @@ uninstall:
rm -f $(DESTDIR)/usr/share/icons/hicolor/128x128/apps/gpgui.png
rm -f $(DESTDIR)/usr/share/icons/hicolor/256x256/apps/gpgui.png
rm -f $(DESTDIR)/usr/share/icons/hicolor/256x256@2/apps/gpgui.png
rm -f $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connected-symbolic.svg
rm -f $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-disconnected-symbolic.svg
rm -f $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-1-symbolic.svg
rm -f $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-2-symbolic.svg
rm -f $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-3-symbolic.svg
rm -f $(DESTDIR)/usr/share/icons/hicolor/scalable/status/gpgui-connecting-4-symbolic.svg
rm -f $(DESTDIR)/usr/share/polkit-1/actions/com.yuezk.gpgui.policy
rm -f $(DESTDIR)/var/lib/gpclient/gpgui \
+4 -29
View File
@@ -71,18 +71,6 @@ Options:
> **Tip:** Use `gpclient help <command>` for detailed information on a specific command.
#### HIP reports
HIP is disabled in the CLI unless enabled explicitly. Use `--hip` to generate reports inside `gpclient`, including later reports requested by the gateway:
```bash
sudo gpclient connect <portal> --hip
```
Use `--hip=/absolute/path/to/script` for a custom executable. It runs as the `gpclient` process user unless `--hip-user` specifies another user. No installed HIP script is discovered automatically. `--hip-user` applies only to custom executables.
`gpclient hip` generates a report on demand for inspection; see `gpclient hip --help` for report inputs. The GUI's HIP tab supports generated reports, edited XML, and HIP Off on all desktop platforms. Linux, FreeBSD, and OpenBSD also support desktop-user scripts and explicitly approved root scripts.
#### External Browser Authentication
For browser-based authentication with the CLI:
@@ -253,11 +241,7 @@ This repository includes a flake for NixOS integration.
#### Installation Steps
Add the flake input and NixOS module to your `flake.nix`:
The module builds the package with your NixOS configuration's `pkgs`, so the
GlobalProtect GUI and the system use the same Nixpkgs dependency versions.
It also enables Polkit and its setuid `pkexec` wrapper for privileged operations.
Add the flake input and package to your `flake.nix`:
```nix
{
@@ -276,11 +260,11 @@ It also enables Polkit and its setuid `pkexec` wrapper for privileged operations
modules = [
./configuration.nix
globalprotect-openconnect.nixosModules.default
{
programs.globalprotect-openconnect.enable = true;
services.ayatana-indicators.enable = true;
environment.systemPackages = [
globalprotect-openconnect.packages.${system}.default
nixpkgs.legacyPackages.${system}.gnomeExtensions.appindicator
];
}
@@ -307,15 +291,6 @@ NixOS does not run an imperative package-uninstall hook when a package is
removed from the system configuration. Remove an installed replacement VPN
script from the app settings before removing the package.
The `prebuilt` package and NixOS module use the published release pinned in `flake.nix`. Both `prebuilt` and `fromSource` run natively on the host with packaged dependencies and installer paths. The `fromSource` package builds the current flake checkout, including its Git submodules:
```bash
git submodule update --init --recursive
nix build "git+file://$PWD?submodules=1#fromSource"
```
Local source builds require initialized Git submodules and a flake URL with `submodules=1`, as shown above. For a remote source flake, use a Git URL with submodules enabled, such as `git+https://github.com/yuezk/GlobalProtect-openconnect?submodules=1#fromSource`. The `prebuilt` package and NixOS module do not require Git submodules. Build output (`target`, `.build`, and `node_modules`) is excluded from the source input. Updating release asset hashes changes the prebuilt package, independently of source builds.
### Official Docker Image
The [official Docker image](https://hub.docker.com/r/yuezk/globalprotect-openconnect) provides the CLI tools on Alpine Linux:
@@ -449,7 +424,7 @@ This project includes a DevContainer configuration that provides a consistent, r
#### Prerequisites
- [Rust 1.91 or later](https://www.rust-lang.org/tools/install)
- [Rust 1.89 or later](https://www.rust-lang.org/tools/install)
- [Tauri dependencies](https://tauri.app/start/prerequisites/)
- OpenConnect source-build dependencies: `autoconf`, `automake`, `autopoint`/`gettext`, `libtool`, `patch`, `pkg-config`, `libxml2`, `zlib`, `lz4`, `gnutls`, `p11-kit`, `nettle`, and `gmp` development packages
- `pkexec` and `gnome-keyring` (or `pam_kwallet` on KDE)
+6 -3
View File
@@ -9,25 +9,28 @@ license.workspace = true
[dependencies]
common = { path = "../../crates/common" }
gpapi = { path = "../../crates/gpapi", features = ["clap"] }
gphip = { path = "../../crates/gphip" }
openconnect = { path = "../../crates/openconnect" }
anyhow.workspace = true
askama.workspace = true
chrono.workspace = true
clap.workspace = true
env_logger.workspace = true
inquire = "0.9"
log.workspace = true
tokio = { workspace = true, features = ["rt-multi-thread"] }
tokio-util.workspace = true
sysinfo.workspace = true
serde.workspace = true
serde_json.workspace = true
serde_urlencoded.workspace = true
whoami.workspace = true
tempfile.workspace = true
reqwest.workspace = true
directories.workspace = true
compile-time.workspace = true
uzers.workspace = true
netdev.workspace = true
xmltree.workspace = true
uuid = { workspace = true, features = ["v5"] }
[features]
default = ["webview-auth"]
+2 -67
View File
@@ -50,21 +50,6 @@ enum CliCommand {
LaunchGui(LaunchGuiArgs),
#[command(about = "Generate HIP report")]
Hip(HipArgs),
#[command(hide = true)]
DetectInternalHost {
#[arg(long)]
address: std::net::IpAddr,
#[arg(long)]
hostname: String,
},
#[command(hide = true)]
ResolveGateway {
host: String,
#[arg(long, default_value_t = 443)]
port: u16,
#[arg(long)]
disable_ipv6: bool,
},
}
#[derive(Parser)]
@@ -133,9 +118,9 @@ impl Args for Cli {
impl Cli {
fn can_run_alongside_client(&self) -> bool {
match &self.command {
CliCommand::Connect(_) => false,
CliCommand::Disconnect(_) => true,
CliCommand::LaunchGui(args) => args.is_auth_callback(),
_ => true,
_ => false,
}
}
@@ -193,20 +178,6 @@ impl Cli {
CliCommand::Disconnect(args) => DisconnectHandler::new(args, shared_args.lock_file).handle().await,
CliCommand::LaunchGui(args) => LaunchGuiHandler::new(args).handle().await,
CliCommand::Hip(args) => HipHandler::new(args).handle().await,
CliCommand::DetectInternalHost { address, hostname } => {
let internal = gpapi::session::network::native::detect_in_helper(*address, hostname)?;
println!("{}", serde_json::to_string(&internal)?);
Ok(())
}
CliCommand::ResolveGateway {
host,
port,
disable_ipv6,
} => {
let addresses = gpapi::session::network::native::lookup_in_helper(host, *port, *disable_ipv6)?;
println!("{}", serde_json::to_string(&addresses)?);
Ok(())
}
}
}
}
@@ -248,23 +219,6 @@ mod tests {
use super::*;
#[test]
fn resolver_helper_runs_alongside_client_and_is_hidden_from_help() {
let cli = Cli::try_parse_from([
"gpclient",
"resolve-gateway",
"localhost",
"--port",
"444",
"--disable-ipv6",
])
.unwrap();
assert!(cli.can_run_alongside_client());
use clap::CommandFactory;
let help = Cli::command().render_help().to_string();
assert!(!help.contains("resolve-gateway"));
}
#[test]
fn lock_file_defaults_to_standard_path() {
let cli = Cli::try_parse_from(["gpclient", "connect", "portal.example.com"]).expect("cli should parse");
@@ -286,25 +240,6 @@ mod tests {
assert_eq!(cli.lock_file, PathBuf::from("/tmp/gpclient-portal.lock"));
}
#[test]
fn hip_can_run_alongside_connected_client() {
let cli = Cli::try_parse_from([
"gpclient",
"hip",
"--client-version",
"6.2.4-49",
"--client-os",
"Mac",
"--cookie",
"user=alice",
"--md5",
"test",
])
.expect("HIP arguments should parse");
assert!(cli.can_run_alongside_client());
}
#[test]
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
fn launch_gui_accepts_auth_callback() {
+2 -32
View File
@@ -54,16 +54,13 @@ pub(crate) struct ConnectArgs {
#[arg(
long,
help = "Enable HIP (Host Information Profile), optionally specify a custom executable",
help = "Use HIP (Host Integrity Protection) extension, optionally specify the HIP script path",
default_missing_value = "",
num_args=0..=1
)]
pub(super) hip: Option<String>,
#[arg(
long,
help = "Run a custom HIP executable as this user; otherwise inherit the process user"
)]
#[arg(long, help = "The user used to run the HIP script")]
pub(super) hip_user: Option<String>,
#[arg(
@@ -152,14 +149,6 @@ pub(crate) struct ConnectArgs {
#[arg(long, help = "Listen on this IP address when using '--browser remote'")]
pub(super) browser_listen: Option<IpAddr>,
#[arg(
long,
help = "Authenticate and print the gateway cookie to stdout, then exit without starting the \
VPN tunnel. Outputs two lines: COOKIE='<value>' and HOST='<gateway>'. Combine with \
--cookie-cache to avoid re-authenticating when the portal session is still valid."
)]
pub(super) cookie_only: bool,
}
pub(super) fn build_os_profile(args: &ConnectArgs) -> OsProfile {
@@ -429,23 +418,4 @@ mod tests {
};
assert_eq!(err.kind(), ErrorKind::ArgumentConflict);
}
#[test]
fn cookie_only_flag_parses() {
use clap::Parser;
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com", "--cookie-only"])
.expect("--cookie-only should parse");
assert!(cli.args.cookie_only);
}
#[test]
fn cookie_only_is_disabled_by_default() {
use clap::Parser;
let cli = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com"]).expect("connect args should parse");
assert!(!cli.args.cookie_only);
}
}
+1 -2
View File
@@ -116,8 +116,7 @@ impl ConnectHandler<'_> {
.clean(clean_auth)
.default_browser(use_default_browser);
let cred = auth_launcher.cancellation(&self.cancellation).launch().await?;
self.check_cancelled()?;
let cred = auth_launcher.launch().await?;
Ok(cred)
}
-173
View File
@@ -1,173 +0,0 @@
use std::time::Duration;
use clap::Parser;
use gpapi::{
cookie_store::{self, StoredCookie},
credential::AuthCookieCredential,
gateway::{Gateway, GatewayLoginContext, GatewaySelection},
log_format::LogFormat,
session::SessionMode,
};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use super::{ConnectArgs, ConnectHandler};
use crate::cli::SharedArgs;
#[derive(Parser)]
struct TestArgs {
#[command(flatten)]
connect: ConnectArgs,
}
fn login_response() -> String {
let mut fields = [""; 20];
fields[1] = "issued-cookie";
fields[3] = "gateway";
fields[4] = "alice";
fields[5] = "fixture-auth";
fields[6] = "vsys1";
fields[12] = "tunnel";
format!(
"<jnlp><application-desc>{}</application-desc></jnlp>",
fields
.iter()
.map(|field| format!("<argument>{field}</argument>"))
.collect::<String>()
)
}
async fn gateway(responses: Vec<(&'static str, String)>) -> (String, tokio::task::JoinHandle<Vec<String>>) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = format!("http://{}", listener.local_addr().unwrap());
let worker = tokio::spawn(async move {
tokio::time::timeout(Duration::from_secs(5), async move {
let mut requests = Vec::new();
for (status, body) in responses {
let (mut stream, _) = listener.accept().await.unwrap();
let mut request = Vec::new();
loop {
let mut buf = [0; 4096];
let count = stream.read(&mut buf).await.unwrap();
assert_ne!(count, 0, "Request ended before its body");
request.extend_from_slice(&buf[..count]);
if let Some(end) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") {
let headers = String::from_utf8_lossy(&request[..end]).to_ascii_lowercase();
let length = headers
.lines()
.find_map(|line| line.strip_prefix("content-length:"))
.map(|value| value.trim().parse::<usize>().unwrap())
.unwrap_or(0);
if request.len() >= end + 4 + length {
break;
}
}
}
requests.push(String::from_utf8(request).unwrap());
stream
.write_all(
format!(
"HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
.as_bytes(),
)
.await
.unwrap();
}
requests
})
.await
.expect("Gateway fixture timed out")
});
(origin, worker)
}
#[tokio::test]
async fn cached_tunnel_authentication_does_not_require_portal_discovery() {
let (gateway, worker) = gateway(vec![("200 OK", login_response())]).await;
let directory = tempfile::tempdir().unwrap();
let cache = directory.path().join("cookie.json");
let args = TestArgs::parse_from([
"test",
"http://unavailable-portal.invalid",
"--cookie-only",
"--cookie-cache",
cache.to_str().unwrap(),
])
.connect;
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
fix_openssl: false,
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
cookie_store::save(
&cache,
&StoredCookie::new(
args.server.clone(),
"alice".into(),
handler.os_profile.borrow().host_identity().host_id().into(),
gateway,
AuthCookieCredential::new("alice", "portal-cookie", ""),
),
)
.unwrap();
handler.handle_impl().await.unwrap();
let requests = worker.await.unwrap();
assert_eq!(requests.len(), 1);
assert!(requests[0].starts_with("POST /ssl-vpn/login.esp "));
assert!(requests[0].contains("portal-cookie"));
assert_eq!(
handler.sessions.borrow().members()[0].transport.authentication().mode(),
SessionMode::Tunnel
);
}
#[tokio::test]
async fn internal_tunnel_keeps_gateway_authentication_after_portal_cookie_rejection() {
let (origin, worker) = gateway(vec![
(
"200 OK",
"<prelogin-response><status>Success</status></prelogin-response>".into(),
),
("403 Forbidden", "<response><error>rejected</error></response>".into()),
("200 OK", login_response()),
])
.await;
let args = TestArgs::parse_from(["test", &origin, "--user", "alice", "--passwd-on-stdin"]).connect;
let directory = tempfile::tempdir().unwrap();
let lock = directory.path().join("client.pid");
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
let shared = SharedArgs {
fix_openssl: false,
ignore_tls_errors: true,
lock_file: &lock,
verbose: &verbose,
log_format: LogFormat::Text,
};
let handler = ConnectHandler::new(&args, &shared);
handler.password_from_stdin.replace(Some("gateway-password".into()));
let mut value = serde_json::to_value(Gateway::new("internal".into(), origin.clone())).unwrap();
value["kind"] = serde_json::json!("internal");
let gateway: Gateway = serde_json::from_value(value).unwrap();
let session = handler
.authenticate_gateway(
&origin,
&origin,
&AuthCookieCredential::new("alice", "rejected-cookie", ""),
false,
GatewayLoginContext::new(&gateway, GatewaySelection::Auto),
)
.await
.unwrap();
assert_eq!(session.authentication.mode(), SessionMode::Tunnel);
assert!(session.extension_auth.binding().is_none());
let requests = worker.await.unwrap();
assert_eq!(requests.len(), 3);
assert!(requests[1].contains("rejected-cookie"));
assert!(requests[2].contains("gateway-password"));
}
+181 -317
View File
@@ -11,16 +11,16 @@ use gpapi::{
clap::report,
cookie_store,
credential::{AuthCookieCredential, Credential},
gateway::{Gateway, GatewayLogin, GatewayLoginClient, GatewayLoginContext, GatewaySelection, SessionExtensionAuth},
gateway::{GatewayLogin, GatewayLoginContext, SessionExtensionAuth, gateway_login, gateway_login_with_context},
gp_params::GpParams,
os_profile::OsProfile,
portal::{PortalConfig, prelogin},
process::users::get_user_by_name,
session::{GatewayAuthentication, SessionMode},
portal::prelogin,
process::users::{get_non_root_user, get_user_by_name},
utils::shutdown_signal,
};
use inquire::Text;
use log::{Level, info, warn};
use openconnect::{HipScript, HipSource, Vpn, VpnBuilder};
use openconnect::{Vpn, VpnBuilder};
use tokio::{runtime::Handle, task::JoinHandle};
use crate::session::{
@@ -31,15 +31,15 @@ use super::{ConnectHandler, args::cookie_cache_path};
const OPENCONNECT_INTERRUPTED_EXIT_CODE: i32 = -4;
pub(super) struct GatewayLoginSession {
pub(super) authentication: GatewayAuthentication,
pub(super) extension_auth: SessionExtensionAuth,
struct GatewayLoginSession {
cookie: String,
extension_auth: SessionExtensionAuth,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum GatewayConnectFailureStage {
BeforeEstablishment,
AfterEstablishment,
BeforeTunnel,
AfterTunnel,
}
#[derive(Debug)]
@@ -49,22 +49,22 @@ pub(super) struct GatewayConnectError {
}
impl GatewayConnectError {
fn before_establishment(error: anyhow::Error) -> Self {
fn before_tunnel(error: anyhow::Error) -> Self {
Self {
stage: GatewayConnectFailureStage::BeforeEstablishment,
stage: GatewayConnectFailureStage::BeforeTunnel,
error,
}
}
fn after_establishment(error: anyhow::Error) -> Self {
fn after_tunnel(error: anyhow::Error) -> Self {
Self {
stage: GatewayConnectFailureStage::AfterEstablishment,
stage: GatewayConnectFailureStage::AfterTunnel,
error,
}
}
pub(super) fn is_before_establishment(&self) -> bool {
self.stage == GatewayConnectFailureStage::BeforeEstablishment
pub(super) fn is_before_tunnel(&self) -> bool {
self.stage == GatewayConnectFailureStage::BeforeTunnel
}
pub(super) fn as_error(&self) -> &anyhow::Error {
@@ -77,81 +77,59 @@ impl GatewayConnectError {
}
impl ConnectHandler<'_> {
pub(super) async fn try_cached_cookie(&self, server: &str) -> Option<anyhow::Result<()>> {
pub(super) async fn try_cached_cookie(&self, server: &str) -> Option<()> {
let path = cookie_cache_path(self.args)?;
let host_id = self.os_profile.borrow().host_identity().host_id().to_string();
let stored = cookie_store::load(&path, server, &host_id)?;
if !stored.auth_cookie.can_authenticate_gateway() {
warn!(
"Cached portal cookie for {} is not usable for gateway authentication. Clearing cache.",
stored.server
);
cookie_store::clear(&path);
return None;
}
let credential = (&stored.auth_cookie).into();
let mut params = self.build_gp_params();
params.set_is_gateway(true);
let session = match self
.login_gateway(&stored.last_gateway, &credential, &params, None)
.await
{
info!(
"Using cached portal cookie for {} (saved_at={}, gateway={})",
stored.server, stored.saved_at, stored.last_gateway
);
let cred: Credential = (&stored.auth_cookie).into();
let mut gp_params = self.build_gp_params();
gp_params.set_is_gateway(true);
let login_session = match self.login_gateway(&stored.last_gateway, &cred, &gp_params, None).await {
Ok(session) => session,
Err(error) => {
if self.cancellation.is_cancelled()
|| error
.downcast_ref::<gpapi::gateway::GatewayLoginProtocolError>()
.is_some()
{
return Some(Err(error));
}
Err(err) => {
warn!(
"Cached portal cookie rejected by gateway {}: {}. Clearing cache and falling back to portal auth.",
stored.last_gateway, err
);
cookie_store::clear(&path);
warn!("Cached gateway authentication failed: {error}");
return None;
}
};
if session.authentication.mode() == SessionMode::NonTunnel && !self.args.cookie_only {
self.logout_gateway(&stored.last_gateway).await;
info!("Cached non-tunnel login requires fresh portal discovery");
return None;
}
let result = self
match self
.connect_gateway(
server,
&stored.last_gateway,
&session.authentication,
&login_session.cookie,
false,
session.extension_auth,
login_session.extension_auth,
)
.await;
match result {
Ok(()) => Some(Ok(())),
Err(error) if self.cancellation.is_cancelled() => Some(Err(error.into_error())),
Err(error) => {
self.logout_gateway(&stored.last_gateway).await;
warn!("Cached gateway connection failed: {}", error.as_error());
.await
{
Ok(()) => Some(()),
Err(err) => {
warn!("Gateway connect failed after cached-cookie login: {}", err.as_error());
None
}
}
}
pub(super) fn cached_portal_credential(&self, server: &str) -> Option<Credential> {
if self.args.cookie_on_stdin {
return None;
}
let path = cookie_cache_path(self.args)?;
let host_id = self.os_profile.borrow().host_identity().host_id().to_string();
let stored = cookie_store::load(&path, server, &host_id)?;
if !stored.auth_cookie.can_authenticate_gateway() {
cookie_store::clear(&path);
return None;
}
info!("Using cached credential for fresh portal discovery");
Some((&stored.auth_cookie).into())
}
pub(super) fn clear_cookie_cache(&self) {
if let Some(path) = cookie_cache_path(self.args) {
cookie_store::clear(&path);
}
}
pub(super) async fn connect_gateway_with_prelogin(
&self,
portal: &str,
@@ -165,11 +143,7 @@ impl ConnectHandler<'_> {
gp_params.set_is_gateway(true);
let gateway_browser_auth_allowed = true;
let prelogin = tokio::select! {
biased;
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
result = prelogin(gateway, &gp_params, self.direct_gateway_prelogin_options()) => result?,
};
let prelogin = prelogin(gateway, &gp_params, self.direct_gateway_prelogin_options()).await?;
let cred = self
.obtain_credential(&prelogin, gateway, gateway_browser_auth_allowed)
.await?;
@@ -182,7 +156,7 @@ impl ConnectHandler<'_> {
.connect_gateway(
portal,
gateway,
&login_session.authentication,
&login_session.cookie,
allow_extend_session,
login_session.extension_auth,
)
@@ -190,101 +164,94 @@ impl ConnectHandler<'_> {
.map_err(GatewayConnectError::into_error)
}
/// Connect to a gateway using the official client's auth flow:
///
/// 1. Call gateway prelogin and retain the response (SAML data is held as a fallback).
/// 2. If the portal provided auth cookies, attempt gateway login using them.
/// 3. If that login succeeds, proceed directly to the VPN connection.
/// 4. If no portal auth cookies exist or portal-cookie login fails, use the retained gateway prelogin response to authenticate
/// against the gateway (SAML or username/password) and obtain a gateway-issued
/// credential.
/// 5. Retry gateway login with the gateway credential (now carrying the gateway's
/// `prelogin-cookie`) and connect on success.
pub(super) async fn connect_gateway_with_fallback(
&self,
portal: &str,
gateway: &Gateway,
portal_cred: &AuthCookieCredential,
config: &PortalConfig,
selection: GatewaySelection,
remaining: &[&Gateway],
) -> Result<(), GatewayConnectError> {
let session = self
.authenticate_gateway(
portal,
gateway.server(),
portal_cred,
config.default_browser().unwrap_or(false),
GatewayLoginContext::new(gateway, selection).with_connect_method(config.connect_method()),
)
.await
.map_err(GatewayConnectError::before_establishment)?;
if !self.args.cookie_only && session.authentication.mode() == SessionMode::NonTunnel {
if gateway.kind() != gpapi::gateway::GatewayKind::Internal {
return Err(GatewayConnectError::after_establishment(anyhow::anyhow!(
"Non-tunnel authentication requires freshly discovered internal gateways"
)));
}
return self
.connect_internal_gateways(portal, config, portal_cred, gateway, session, remaining)
.await
.map_err(GatewayConnectError::after_establishment);
}
self
.connect_gateway(
portal,
gateway.server(),
&session.authentication,
config.allow_extend_session().unwrap_or(false),
session.extension_auth,
)
.await
}
pub(super) async fn authenticate_gateway(
&self,
portal: &str,
gateway: &str,
portal_cred: &AuthCookieCredential,
allow_extend_session: bool,
portal_config_default_browser: bool,
gateway_context: GatewayLoginContext,
) -> anyhow::Result<GatewayLoginSession> {
self.check_cancelled()?;
) -> Result<(), GatewayConnectError> {
info!("Connecting to gateway with portal-cookie first, gateway prelogin fallback...");
let mut gp_params = self.build_gp_params();
gp_params.set_is_gateway(true);
let browser_allowed = self.gateway_browser_auth_allowed(portal_config_default_browser);
let gateway_prelogin = tokio::select! {
biased;
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
result = prelogin(gateway, &gp_params, self.prelogin_options(browser_allowed)) => result?,
};
self.check_cancelled()?;
let gateway_browser_auth_allowed = self.gateway_browser_auth_allowed(portal_config_default_browser);
let gateway_prelogin = prelogin(gateway, &gp_params, self.prelogin_options(gateway_browser_auth_allowed))
.await
.map_err(GatewayConnectError::before_tunnel)?;
if portal_cred.can_authenticate_gateway() {
let credential: Credential = portal_cred.into();
let portal_cred_for_login: Credential = portal_cred.into();
match self
.login_gateway(gateway, &credential, &gp_params, Some(&gateway_context))
.login_gateway(gateway, &portal_cred_for_login, &gp_params, Some(&gateway_context))
.await
{
Ok(session) => {
Ok(login_session) => {
info!("Gateway login with portal auth cookies succeeded");
self.save_cookie_cache(portal, gateway, portal_cred);
return Ok(session);
return self
.connect_gateway(
portal,
gateway,
&login_session.cookie,
allow_extend_session,
login_session.extension_auth,
)
.await;
}
Err(error) => {
self.check_cancelled()?;
if error
.downcast_ref::<gpapi::gateway::GatewayLoginProtocolError>()
.is_some()
{
return Err(error);
}
info!("Portal cookie login failed; using gateway prelogin authentication: {error}");
Err(err) => {
info!("Gateway login with portal auth cookies failed: {}", err);
info!("Falling back to gateway prelogin authentication...");
}
}
} else {
info!("Portal config did not provide gateway auth cookies; using gateway prelogin flow");
}
let credential = self
.obtain_credential(&gateway_prelogin, gateway, browser_allowed)
let gateway_cred = match self
.obtain_credential(&gateway_prelogin, gateway, gateway_browser_auth_allowed)
.await
{
Ok(cred) => cred,
Err(err) => {
self.print_direct_gateway_recommendation(gateway);
return Err(GatewayConnectError::before_tunnel(err));
}
};
let login_session = match self
.login_gateway(gateway, &gateway_cred, &gp_params, Some(&gateway_context))
.await
{
Ok(login_session) => login_session,
Err(err) => {
self.print_direct_gateway_recommendation(gateway);
return Err(GatewayConnectError::before_tunnel(err));
}
};
self
.connect_gateway(
portal,
gateway,
&login_session.cookie,
allow_extend_session,
login_session.extension_auth,
)
.await
.inspect_err(|_| self.print_direct_gateway_recommendation(gateway))?;
self.check_cancelled()?;
let result = self
.login_gateway(gateway, &credential, &gp_params, Some(&gateway_context))
.await;
if result.is_err() {
self.print_direct_gateway_recommendation(gateway);
}
result
}
fn save_cookie_cache(&self, portal: &str, gateway: &str, auth_cookie: &AuthCookieCredential) {
@@ -341,39 +308,24 @@ impl ConnectHandler<'_> {
gateway_context: Option<&GatewayLoginContext>,
) -> anyhow::Result<GatewayLoginSession> {
let mut gp_params = gp_params.clone();
gp_params.prepare_client_identity()?;
let cancellation = self.cancellation.clone();
let internal = gateway_context.is_some_and(|context| context.kind() == gpapi::gateway::GatewayKind::Internal);
let mut client = GatewayLoginClient::new(gateway, gp_params)?;
loop {
self.check_cancelled()?;
let login = client.login(cred, gateway_context, &cancellation).await?;
let login = match gateway_context {
Some(context) => gateway_login_with_context(gateway, cred, &gp_params, context).await?,
None => gateway_login(gateway, cred, &gp_params).await?,
};
match login {
GatewayLogin::Authenticated(authentication) => {
let descriptor = Gateway::new(gateway.to_string(), gateway.to_string());
client.register_session(
descriptor.clone(),
authentication.clone(),
&mut self.sessions.borrow_mut(),
);
self.check_cancelled()?;
if internal && authentication.mode() == SessionMode::NonTunnel && !self.args.cookie_only {
client
.bind_non_tunnel(self.args.disable_ipv6, None, &cancellation)
.await
.map_err(|error| error.context(gpapi::gateway::GatewayLoginProtocolError))?;
client.update_registered_session(&descriptor, &authentication, &mut self.sessions.borrow_mut());
}
GatewayLogin::Cookie(cookie) => {
return Ok(GatewayLoginSession {
authentication,
extension_auth: SessionExtensionAuth::new(cred.clone(), client),
cookie,
extension_auth: SessionExtensionAuth::new(cred.clone(), gp_params),
});
}
GatewayLogin::Mfa(message, input_str) => {
let otp = Text::new(&message).prompt()?;
client.respond_mfa(&input_str, &otp);
gp_params.set_input_str(&input_str);
gp_params.set_otp(&otp);
info!("Retrying gateway login with MFA...");
}
@@ -381,58 +333,28 @@ impl ConnectHandler<'_> {
}
}
pub(super) async fn connect_gateway(
async fn connect_gateway(
&self,
portal: &str,
gateway: &str,
authentication: &GatewayAuthentication,
cookie: &str,
allow_extend_session: bool,
extension_auth: SessionExtensionAuth,
) -> Result<(), GatewayConnectError> {
let cookie = authentication.cookie();
// --cookie-only: print the gateway cookie and exit without opening a tunnel.
// No tun device is allocated, no root is required, and no logout is issued
// against the gateway — the cookie remains valid for subsequent use.
// Output format matches openconnect --authenticate for easy shell consumption.
if self.args.cookie_only {
println!("COOKIE='{}'", cookie);
println!("HOST='{}'", gateway);
return Ok(());
}
if authentication.mode() != SessionMode::Tunnel {
return Err(GatewayConnectError::after_establishment(anyhow::anyhow!(
"Non-tunnel authentication requires fresh internal portal discovery"
)));
}
self
.check_cancelled()
.map_err(GatewayConnectError::after_establishment)?;
let identity_files = extension_auth
.client_identity()
.map(|identity| identity.write_files(None))
.transpose()
.map_err(GatewayConnectError::before_establishment)?;
let certificate = identity_files.as_ref().map(|files| files.certificate().to_owned());
let sslkey = identity_files.as_ref().and_then(|files| files.key().map(str::to_owned));
let key_password = extension_auth
.client_identity()
.and_then(|identity| identity.key_password())
.map(str::to_owned);
let mtu = self.args.mtu.unwrap_or(0);
let (hip, csd_wrapper) = self.determine_hip_script();
let hip_user = self.determine_hip_user();
let csd_uid = get_uid(&hip_user).map_err(GatewayConnectError::before_tunnel)?;
let os_profile = self.os_profile.borrow().clone();
let hip_source = self
.hip_source(os_profile.clone())
.map_err(GatewayConnectError::before_establishment)?;
let session_ctx = build_session_context(SessionContextInput {
portal: portal.to_string(),
gateway: gateway.to_string(),
cookie: cookie.to_string(),
os_profile: os_profile.clone(),
certificate: certificate.clone(),
sslkey: sslkey.clone(),
key_password: key_password.clone(),
certificate: self.args.certificate.clone(),
sslkey: self.args.sslkey.clone(),
key_password: self.latest_key_password.borrow().clone(),
disable_ipv6: self.args.disable_ipv6,
extension_auth: Some(extension_auth),
});
@@ -440,10 +362,12 @@ impl ConnectHandler<'_> {
.script(self.args.script.clone())
.interface(self.args.interface.clone())
.script_tun(self.args.script_tun)
.certificate(certificate)
.sslkey(sslkey)
.key_password(key_password)
.hip_source(hip_source)
.certificate(self.args.certificate.clone())
.sslkey(self.args.sslkey.clone())
.key_password(self.latest_key_password.borrow().clone())
.hip(hip)
.csd_uid(csd_uid)
.csd_wrapper(csd_wrapper)
.reconnect_timeout(self.args.reconnect_timeout)
.mtu(mtu)
.disable_ipv6(self.args.disable_ipv6)
@@ -453,7 +377,7 @@ impl ConnectHandler<'_> {
.no_xmlpost(self.args.no_xmlpost);
let vpn = apply_os_profile(vpn_builder, &os_profile)
.build()
.map_err(|err| GatewayConnectError::before_establishment(err.into()))?;
.map_err(|err| GatewayConnectError::before_tunnel(err.into()))?;
let vpn = Arc::new(vpn);
let vpn_clone = vpn.clone();
@@ -466,97 +390,55 @@ impl ConnectHandler<'_> {
let tunnel_established_on_connect = Arc::clone(&tunnel_established);
let disconnect_requested = Arc::new(AtomicBool::new(false));
let disconnect_requested_on_signal = Arc::clone(&disconnect_requested);
let cancellation = self.cancellation.clone();
let disconnect_task = tokio::spawn(async move {
cancellation.cancelled().await;
tokio::spawn(async move {
shutdown_signal().await;
info!("Received the interrupt signal, disconnecting...");
disconnect_requested_on_signal.store(true, Ordering::SeqCst);
vpn_clone.disconnect();
});
let lock_file_on_connect = self.shared_args.lock_file.to_path_buf();
let pid_written = self.pid_written.clone();
let lock_file = self.shared_args.lock_file.to_path_buf();
let lock_file_on_connect = lock_file.clone();
let log_format = self.shared_args.log_format;
let session_cancellation = self.cancellation.clone();
let (established_tx, established_rx) = tokio::sync::oneshot::channel();
self.sessions.borrow_mut().relinquish_gateway(gateway);
let worker = tokio::task::spawn_blocking(move || {
vpn.connect(move |vpn_session_info| {
if session_cancellation.is_cancelled() {
return;
}
tunnel_established_on_connect.store(true, Ordering::SeqCst);
pid_written.store(write_pid_file(&lock_file_on_connect), Ordering::SeqCst);
let _ = established_tx.send(());
let connect_result = vpn.connect(move |vpn_session_info| {
tunnel_established_on_connect.store(true, Ordering::SeqCst);
write_pid_file(&lock_file_on_connect);
let Some(session_ctx) = session_ctx_on_connect.lock().unwrap().take() else {
return;
};
let session_info = session_info_from_vpn(vpn_session_info, allow_extend_session);
info!("VPN session info: {}", session_info.log_summary());
let Some(session_ctx) = session_ctx_on_connect.lock().unwrap().take() else {
return;
};
let session_info = session_info_from_vpn(vpn_session_info, allow_extend_session);
info!("VPN session info: {}", session_info.log_summary());
let task = spawn_session_runtime_with_info(&runtime_handle, session_ctx, session_info, log_format);
session_task_on_connect.lock().unwrap().replace(task);
})
let task = spawn_session_runtime_with_info(&runtime_handle, session_ctx, session_info, log_format);
session_task_on_connect.lock().unwrap().replace(task);
});
tokio::pin!(worker);
let connect_result = tokio::select! {
result = &mut worker => result,
established = established_rx => {
if established.is_ok() {
let unused = self.sessions.borrow().members().iter()
.filter(|session| session.gateway.server() != gateway)
.map(|session| session.gateway.server().to_owned())
.collect::<Vec<_>>();
for server in unused {
self.logout_gateway(&server).await;
}
}
(&mut worker).await
}
};
let tunnel_established = tunnel_established.load(Ordering::SeqCst);
disconnect_task.abort();
let _ = disconnect_task.await;
let session_task = { session_task.lock().unwrap().take() };
if let Some(task) = session_task {
if let Some(task) = session_task.lock().unwrap().take() {
task.abort();
let _ = task.await;
}
if fs::metadata(&lock_file).is_ok() {
info!("Removing PID file");
fs::remove_file(&lock_file).map_err(|err| GatewayConnectError::after_tunnel(err.into()))?;
}
let disconnect_requested = disconnect_requested.load(Ordering::SeqCst);
let connect_result = connect_result.map_err(|error| GatewayConnectError::after_establishment(error.into()))?;
classify_openconnect_result(connect_result, tunnel_established, disconnect_requested)
}
pub(super) fn hip_source(&self, profile: OsProfile) -> anyhow::Result<HipSource> {
let user = self.determine_hip_user();
let script = self.args.hip.as_ref().or(self.args.csd_wrapper.as_ref());
match script {
Some(path) if !path.is_empty() => Ok(HipSource::Script(HipScript::new(path.clone(), get_uid(&user)?)?)),
Some(_) => {
anyhow::ensure!(user.is_none(), "--hip-user requires an explicit HIP script");
Ok(HipSource::Generator(Arc::new(move |request, control| {
let input = gphip::ReportInput {
profile: profile.clone(),
context: gphip::ReportContext::Connected {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
},
};
gphip::generate_report_with_control(&input, &|| control.check())
.map_err(|error| error.downcast::<std::io::Error>().unwrap_or_else(std::io::Error::other))
})))
}
None => {
anyhow::ensure!(user.is_none(), "--hip-user requires an explicit HIP script");
Ok(HipSource::Disabled)
}
fn determine_hip_script(&self) -> (bool, Option<String>) {
if let Some(hip) = &self.args.hip {
return if hip.is_empty() {
(true, None)
} else {
(true, Some(hip.clone()))
};
}
(self.args.csd_wrapper.is_some(), self.args.csd_wrapper.clone())
}
fn determine_hip_user(&self) -> Option<String> {
@@ -583,9 +465,9 @@ fn classify_openconnect_result(
let error = anyhow::anyhow!("OpenConnect exited with status {}", exit_code);
if tunnel_established {
Err(GatewayConnectError::after_establishment(error))
Err(GatewayConnectError::after_tunnel(error))
} else {
Err(GatewayConnectError::before_establishment(error))
Err(GatewayConnectError::before_tunnel(error))
}
}
@@ -593,23 +475,22 @@ fn direct_gateway_command(gateway: &str) -> String {
format!("gpauth --gateway {gateway} | sudo gpclient connect {gateway} --as-gateway --cookie-on-stdin")
}
pub(super) fn write_pid_file(lock_file: &Path) -> bool {
fn write_pid_file(lock_file: &Path) {
let pid = std::process::id();
if let Err(err) = fs::write(lock_file, pid.to_string()) {
warn!("Failed to write PID file: {}", err);
false
} else {
info!("Wrote PID {} to {}", pid, lock_file.display());
true
}
}
fn get_uid(user: &Option<String>) -> anyhow::Result<Option<u32>> {
user
.as_ref()
.map(|user| get_user_by_name(user).map(|user| user.uid()))
.transpose()
fn get_uid(user: &Option<String>) -> anyhow::Result<u32> {
if let Some(user) = user {
get_user_by_name(user).map(|user| user.uid())
} else {
get_non_root_user().map_or_else(|_| Ok(0), |user| Ok(user.uid()))
}
}
fn apply_os_profile(builder: VpnBuilder, profile: &OsProfile) -> VpnBuilder {
@@ -625,23 +506,6 @@ fn apply_os_profile(builder: VpnBuilder, profile: &OsProfile) -> VpnBuilder {
mod tests {
use super::*;
#[test]
fn hip_script_defaults_to_inherited_process_identity() {
assert_eq!(get_uid(&None).unwrap(), None);
}
#[test]
fn explicit_hip_user_must_exist() {
assert!(get_uid(&Some("gpclient-nonexistent-hip-user".to_string())).is_err());
}
#[test]
fn explicit_hip_user_resolves_to_the_selected_account() {
let current = uzers::get_user_by_uid(uzers::get_effective_uid()).unwrap();
let name = current.name().to_string_lossy().into_owned();
assert_eq!(get_uid(&Some(name)).unwrap(), Some(current.uid()));
}
#[test]
fn openconnect_success_is_not_a_gateway_failure() {
assert!(classify_openconnect_result(0, false, false).is_ok());
@@ -652,14 +516,14 @@ mod tests {
fn openconnect_failure_before_callback_is_retryable_gateway_failure() {
let err = classify_openconnect_result(1, false, false).expect_err("nonzero exit should fail");
assert!(err.is_before_establishment());
assert!(err.is_before_tunnel());
}
#[test]
fn openconnect_failure_after_callback_is_terminal_gateway_failure() {
let err = classify_openconnect_result(1, true, false).expect_err("nonzero exit should fail");
assert!(!err.is_before_establishment());
assert!(!err.is_before_tunnel());
}
#[test]
@@ -672,7 +536,7 @@ mod tests {
let err = classify_openconnect_result(OPENCONNECT_INTERRUPTED_EXIT_CODE, true, false)
.expect_err("unexpected interrupt should fail");
assert!(!err.is_before_establishment());
assert!(!err.is_before_tunnel());
}
#[test]
-226
View File
@@ -1,226 +0,0 @@
use std::sync::Arc;
use anyhow::{Context, bail, ensure};
use gpapi::{
credential::AuthCookieCredential,
gateway::{Gateway, GatewayLoginContext, GatewaySelection},
portal::PortalConfig,
process::collection::CollectionControl,
session::{
MaintenanceState, SessionEndReason, SessionMode,
network::PhysicalNetwork,
non_tunnel::{SessionCallbacks, SessionExit, maintain_non_tunnel_sessions},
},
};
use log::{info, warn};
use super::ConnectHandler;
impl ConnectHandler<'_> {
pub(super) async fn connect_internal_gateways(
&self,
portal: &str,
config: &PortalConfig,
credential: &AuthCookieCredential,
first_gateway: &Gateway,
first_session: super::gateway::GatewayLoginSession,
remaining: &[&Gateway],
) -> anyhow::Result<()> {
ensure!(remaining.len() < 64, "Too many internal non-tunnel candidates");
let mut hosts = std::collections::HashSet::new();
for gateway in std::iter::once(first_gateway).chain(remaining.iter().copied()) {
ensure!(
gateway.kind() == gpapi::gateway::GatewayKind::Internal,
"Non-tunnel candidates must be internal"
);
ensure!(
hosts.insert(gpapi::utils::normalize_server(gateway.server())?),
"Duplicate internal gateway"
);
}
let mut authenticated = vec![(first_gateway, first_session)];
for gateway in remaining.iter().copied() {
self.check_cancelled()?;
let context =
GatewayLoginContext::new(gateway, GatewaySelection::Auto).with_connect_method(config.connect_method());
match self
.authenticate_gateway(
portal,
gateway.server(),
credential,
config.default_browser().unwrap_or(false),
context,
)
.await
{
Ok(session) => authenticated.push((gateway, session)),
Err(error) => {
self.logout_gateway(gateway.server()).await;
self.check_cancelled()?;
warn!("Internal gateway {gateway} authentication failed: {error}");
}
}
}
self.check_cancelled()?;
let modes = authenticated.iter().map(|(_, session)| session.authentication.mode());
ensure!(
internal_session_mode(modes)? == SessionMode::NonTunnel,
"Expected non-tunnel authentication"
);
self.run_internal_session(config, &authenticated).await
}
async fn run_internal_session(
&self,
config: &PortalConfig,
authenticated: &[(&gpapi::gateway::Gateway, super::gateway::GatewayLoginSession)],
) -> anyhow::Result<()> {
let cancellation = self.cancellation.clone();
let network = Arc::new(PhysicalNetwork::capture_controlled(&cancellation).await?);
let detection = config.internal_detection().cloned();
let bindings = authenticated
.iter()
.map(|(_, session)| {
session
.extension_auth
.binding()
.cloned()
.context("Non-tunnel binding is missing")
})
.collect::<anyhow::Result<Vec<_>>>()?;
for binding in &bindings {
network
.validate_internal_binding(binding, detection.as_ref(), &cancellation)
.await?;
}
let policy = config
.internal_session_policy()
.context("Invalid internal session policy")?;
let profile = self.os_profile.borrow().clone();
let source = if policy.collect_hip_data() {
self.hip_source(profile.clone())?
} else {
openconnect::HipSource::Disabled
};
let source = Arc::new(source);
let validate_network = network.clone();
let validate_detection = detection.clone();
let callbacks = SessionCallbacks {
produce_report: Arc::new(move |request, control| {
control.check()?;
if matches!(source.as_ref(), openconnect::HipSource::Disabled) {
return gphip::generate_identity_report(&gphip::ReportInput {
profile: profile.clone(),
context: gphip::ReportContext::Connected {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
},
})
.map_err(std::io::Error::other);
}
source.collect(
&openconnect::HipRequest {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
client_version: profile.client_version().into(),
client_os: profile.client_os().as_str().into(),
os_version: profile.os_version().into(),
host_id: Some(profile.host_id().into()),
local_hostname: Some(profile.computer().into()),
},
&|| control.check(),
)
}),
report_submitted: Arc::new(|_, _| {}),
status_changed: Arc::new(|member| match member.maintenance {
MaintenanceState::Healthy => info!(
"Internal network — authenticated: {} (IPv4: {:?}, IPv6: {:?})",
member.gateway, member.client_ip, member.client_ipv6
),
state => info!("Internal gateway {}: {state:?}", member.gateway),
}),
validate_network: Arc::new(move |cancellation| {
let network = validate_network.clone();
let detection = validate_detection.clone();
let bindings = bindings.clone();
Box::pin(async move {
for binding in &bindings {
network
.validate_internal_binding(binding, detection.as_ref(), &cancellation)
.await?;
}
Ok(())
})
}),
};
let monitor_cancel = cancellation.child_token();
let monitor_token = monitor_cancel.clone();
let (network_changed, network_signal) = tokio::sync::oneshot::channel();
let monitor = tokio::spawn(async move {
match network.wait_for_change(detection, monitor_token).await {
Ok(false) => {}
Ok(true) | Err(_) => {
let _ = network_changed.send(SessionEndReason::NetworkChanged);
}
}
});
// The PID spans maintenance and cleanup, including initialization before the
// first successful HIP exchange. The outer handler owns final session logout.
self.pid_written.store(
super::gateway::write_pid_file(self.shared_args.lock_file),
std::sync::atomic::Ordering::SeqCst,
);
let mut sessions = self.sessions.take();
let result = maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation, async move {
network_signal.await.unwrap_or(SessionEndReason::NetworkChanged)
})
.await;
self.sessions.replace(sessions);
monitor_cancel.cancel();
monitor.await.context("Internal network monitor failed")?;
match result? {
SessionExit::Disconnected => Ok(()),
SessionExit::Failed(reason) => bail!("Internal session ended: {reason:?}. Connect again to authenticate."),
}
}
pub(super) async fn logout_gateway(&self, gateway: &str) {
let mut sessions = self.sessions.take();
sessions.logout_gateway(gateway).await;
self.sessions.replace(sessions);
}
}
fn internal_session_mode(modes: impl Iterator<Item = SessionMode>) -> anyhow::Result<SessionMode> {
let mut modes = modes;
let mode = modes.next().context("No internal gateway authenticated successfully")?;
ensure!(
modes.all(|candidate| candidate == mode),
"Mixed tunnel and non-tunnel internal gateways are unsupported; select a gateway explicitly"
);
Ok(mode)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn internal_modes_reject_mixed_and_empty_sets() {
assert!(internal_session_mode([].into_iter()).is_err());
assert!(internal_session_mode([SessionMode::Tunnel, SessionMode::NonTunnel].into_iter()).is_err());
assert_eq!(
internal_session_mode([SessionMode::NonTunnel, SessionMode::NonTunnel].into_iter()).unwrap(),
SessionMode::NonTunnel
);
assert_eq!(
internal_session_mode([SessionMode::Tunnel].into_iter()).unwrap(),
SessionMode::Tunnel
);
}
}
+25 -94
View File
@@ -1,25 +1,17 @@
mod args;
mod credential;
#[cfg(test)]
mod flow_tests;
mod gateway;
mod internal;
use std::cell::RefCell;
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use anyhow::bail;
use gpapi::{
clap::report,
error::PortalError,
gateway::GatewaySelection,
gateway::{GatewayLoginContext, GatewaySelection},
gp_params::GpParams,
os_profile::OsProfile,
portal::{PreloginOptions, prelogin, retrieve_config},
session::GatewaySessions,
utils::request::RequestIdentityError,
};
use inquire::{Password, PasswordDisplayMode, Select};
@@ -33,7 +25,6 @@ use credential::CleanAuthState;
use gateway::GatewayConnectError;
pub(crate) struct ConnectHandler<'a> {
cancellation: tokio_util::sync::CancellationToken,
args: &'a ConnectArgs,
shared_args: &'a SharedArgs<'a>,
os_profile: RefCell<OsProfile>,
@@ -41,8 +32,6 @@ pub(crate) struct ConnectHandler<'a> {
password_from_stdin: RefCell<Option<String>>,
cookie_from_stdin: RefCell<Option<String>>,
clean_auth_state: RefCell<CleanAuthState>,
sessions: RefCell<GatewaySessions>,
pid_written: Arc<AtomicBool>,
}
impl<'a> ConnectHandler<'a> {
@@ -55,7 +44,6 @@ impl<'a> ConnectHandler<'a> {
let clean_auth = false;
Self {
cancellation: tokio_util::sync::CancellationToken::new(),
args,
shared_args,
os_profile: RefCell::new(build_os_profile(args)),
@@ -63,8 +51,6 @@ impl<'a> ConnectHandler<'a> {
password_from_stdin: Default::default(),
cookie_from_stdin: Default::default(),
clean_auth_state: RefCell::new(CleanAuthState::new(clean_auth)),
sessions: RefCell::default(),
pid_written: Arc::default(),
}
}
@@ -107,37 +93,6 @@ impl<'a> ConnectHandler<'a> {
}
pub(crate) async fn handle(&self) -> anyhow::Result<()> {
let cancellation = self.cancellation.clone();
let signal = tokio::spawn(async move {
gpapi::utils::shutdown_signal().await;
cancellation.cancel();
});
let result = self.handle_attempt().await;
let sessions = self.sessions.take();
if self.args.cookie_only && result.is_ok() {
sessions.relinquish();
} else {
sessions.logout().await;
}
if self.pid_written.load(Ordering::SeqCst) {
if let Err(error) = std::fs::remove_file(self.shared_args.lock_file) {
warn!("Failed to remove PID file: {error}");
}
}
signal.abort();
let _ = signal.await;
result
}
fn check_cancelled(&self) -> anyhow::Result<()> {
if self.cancellation.is_cancelled() {
Err(gpapi::auth::AuthenticationCancelled.into())
} else {
Ok(())
}
}
async fn handle_attempt(&self) -> anyhow::Result<()> {
if self.args.browser_listen.is_some()
&& !matches!(self.args.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("remote"))
{
@@ -152,7 +107,6 @@ impl<'a> ConnectHandler<'a> {
self.latest_key_password.replace(self.args.key_password.clone());
loop {
self.check_cancelled()?;
let Err(err) = self.handle_impl().await else {
return Ok(());
};
@@ -190,7 +144,6 @@ impl<'a> ConnectHandler<'a> {
}
pub(crate) async fn handle_impl(&self) -> anyhow::Result<()> {
self.check_cancelled()?;
let server = self.args.server.as_str();
let as_gateway = self.args.as_gateway;
@@ -202,11 +155,10 @@ impl<'a> ConnectHandler<'a> {
}
if !self.args.cookie_on_stdin {
if let Some(result) = self.try_cached_cookie(server).await {
return result;
if let Some(()) = self.try_cached_cookie(server).await {
return Ok(());
}
}
self.check_cancelled()?;
let Err(err) = self.connect_portal_with_prelogin(server).await else {
return Ok(());
@@ -238,35 +190,10 @@ impl<'a> ConnectHandler<'a> {
async fn connect_portal_with_prelogin(&self, portal: &str) -> anyhow::Result<()> {
let gp_params = self.build_gp_params();
let prelogin = tokio::select! {
biased;
_ = self.cancellation.cancelled() => return Err(gpapi::auth::AuthenticationCancelled.into()),
result = prelogin(portal, &gp_params, self.prelogin_options(false)) => result?,
};
let prelogin = prelogin(portal, &gp_params, self.prelogin_options(false)).await?;
let cached = self.cached_portal_credential(portal);
let cached_config = match cached {
Some(cred) => match retrieve_config(portal, &cred, &gp_params, &self.cancellation).await {
Ok(config) => Some((cred, config)),
Err(error) => {
self.check_cancelled()?;
warn!("Cached portal authentication failed: {error}");
self.clear_cookie_cache();
None
}
},
None => None,
};
let (cred, mut portal_config) = match cached_config {
Some(result) => result,
None => {
let cred = self.obtain_credential(&prelogin, portal, false).await?;
self.check_cancelled()?;
let config = retrieve_config(portal, &cred, &gp_params, &self.cancellation).await?;
(cred, config)
}
};
self.check_cancelled()?;
let cred = self.obtain_credential(&prelogin, portal, false).await?;
let mut portal_config = retrieve_config(portal, &cred, &gp_params).await?;
portal_config.sort_gateways(prelogin.region());
@@ -274,6 +201,7 @@ impl<'a> ConnectHandler<'a> {
Some(password) => portal_config.auth_cookie().clone().with_password(password),
None => portal_config.auth_cookie().clone(),
};
let allow_extend_session = portal_config.allow_extend_session().unwrap_or(false);
let portal_config_default_browser = portal_config.default_browser().unwrap_or(false);
info!("Portal config default-browser: {}", portal_config_default_browser);
@@ -289,27 +217,29 @@ impl<'a> ConnectHandler<'a> {
);
let mut last_err: Option<anyhow::Error> = None;
for (index, gateway) in gateways.iter().enumerate() {
for gateway in &gateways {
info!("Auto-gateway: attempting gateway {}", gateway);
let gateway_context =
GatewayLoginContext::new(gateway, GatewaySelection::Auto).with_connect_method(portal_config.connect_method());
match self
.connect_gateway_with_fallback(
portal,
gateway,
gateway.server(),
&auth_cookie,
&portal_config,
GatewaySelection::Auto,
&gateways[index + 1..],
allow_extend_session,
portal_config_default_browser,
gateway_context,
)
.await
{
Ok(()) => return Ok(()),
Err(err) => {
self.logout_gateway(gateway.server()).await;
if !err.is_before_establishment() {
if !err.is_before_tunnel() {
return Err(err.into_error());
}
warn!(
"Auto-gateway: gateway {} failed before session establishment: {}",
"Auto-gateway: gateway {} failed before tunnel setup: {}",
gateway,
err.as_error()
);
@@ -340,9 +270,6 @@ impl<'a> ConnectHandler<'a> {
None => {
let gateways = portal_config.gateways();
if gateways.is_empty() {
bail!("No gateways available in portal configuration");
}
if gateways.len() > 1 {
let gateway = Select::new("Which gateway do you want to connect to?", gateways)
.with_vim_mode(true)
@@ -356,14 +283,18 @@ impl<'a> ConnectHandler<'a> {
}
};
let gateway = selected_gateway.server();
let gateway_context =
GatewayLoginContext::new(selected_gateway, gateway_selection).with_connect_method(portal_config.connect_method());
self
.connect_gateway_with_fallback(
portal,
selected_gateway,
gateway,
&auth_cookie,
&portal_config,
gateway_selection,
&[],
allow_extend_session,
portal_config_default_browser,
gateway_context,
)
.await
.map_err(GatewayConnectError::into_error)
+536 -25
View File
@@ -1,12 +1,122 @@
use std::time::Duration;
use askama::Template;
use clap::Args;
use gpapi::{
clap::args::Os,
os_profile::{ClientOs, OsProfileBuilder},
process::collection::CollectionBudget,
os_profile::{ClientOs, OsProfile, OsProfileBuilder},
};
use gphip::{ReportContext, ReportInput, generate_report_with_control};
use log::debug;
use serde::Deserialize;
use std::collections::HashMap;
use std::process::Command;
use xmltree::Element;
#[derive(Template)]
#[template(path = "hip_report.xml")]
struct HipReportTemplate<'a> {
client_version: &'a str,
generate_time: String,
day: String,
month: String,
year: String,
user_name: &'a str,
host_info: HostInfo,
md5: &'a str,
}
#[derive(Debug, Clone, Deserialize)]
struct DefenderInfo {
#[serde(rename = "appVersion")]
app_version: String,
#[serde(rename = "engineVersion")]
engine_version: String,
#[serde(rename = "definitionsVersion")]
definitions_version: String,
#[serde(rename = "realTimeProtectionEnabled")]
real_time_protection_enabled: RealTimeProtection,
}
#[derive(Debug, Clone, Deserialize)]
struct RealTimeProtection {
value: bool,
}
/// Host information for HIP reporting
struct HostInfo {
/// Common for all OSes, e.g., "Apple", "Microsoft", "Linux"
os_vendor: String,
/// Common for all OSes, e.g., "Linux Ubuntu 20.04", "Apple Mac OS X 10.15.7", etc.
os_version: String,
/// Per-OS machine identifier (UUID for Linux/Windows, MAC for macOS)
host_id: String,
/// Common for all OSes
host_name: String,
/// Only for macOS and Windows, e.g., "10.15.7", "10.0.19044.2130"
software_version: String,
domain: String,
network_interfaces: Vec<NetworkInterface>,
defender: Option<DefenderInfo>,
}
impl HostInfo {
/// Get the first available IPv4 address from network interfaces
pub fn default_ipv4(&self) -> &str {
self
.network_interfaces
.first()
.and_then(|iface| iface.ipv4.as_deref())
.unwrap_or_default()
}
/// Get the first available IPv6 address from network interfaces
pub fn default_ipv6(&self) -> &str {
self
.network_interfaces
.first()
.and_then(|iface| iface.ipv6.as_deref())
.unwrap_or_default()
}
}
/// Network interface information
#[derive(Clone)]
struct NetworkInterface {
name: String,
description: String,
mac_address: Option<String>,
ipv4: Option<String>,
ipv6: Option<String>,
}
impl NetworkInterface {
/// Create a new network interface with basic information
fn new(name: String, description: String) -> Self {
Self {
name,
description,
mac_address: None,
ipv4: None,
ipv6: None,
}
}
/// Set MAC address
fn with_mac(mut self, mac: Option<String>) -> Self {
self.mac_address = mac;
self
}
/// Set IPv4 address
fn with_ipv4(mut self, ipv4: Option<String>) -> Self {
self.ipv4 = ipv4;
self
}
/// Set IPv6 address
fn with_ipv6(mut self, ipv6: Option<String>) -> Self {
self.ipv6 = ipv6;
self
}
}
#[derive(Args)]
pub(crate) struct HipArgs {
@@ -37,33 +147,434 @@ pub(crate) struct HipArgs {
pub(crate) struct HipHandler<'a> {
args: &'a HipArgs,
profile: OsProfile,
}
impl<'a> HipHandler<'a> {
pub(crate) fn new(args: &'a HipArgs) -> Self {
Self { args }
let profile = build_os_profile(args);
Self { args, profile }
}
pub(crate) async fn handle(&self) -> anyhow::Result<()> {
let budget = CollectionBudget::new(Duration::from_secs(60));
let client_os = ClientOs::from(self.args.client_os);
let mut builder = OsProfileBuilder::new(client_os).client_version(self.args.client_version.clone());
if let Some(os_version) = self.args.os_version.as_deref() {
builder = builder.os_version(os_version);
}
if let Some(host_id) = self.args.host_id.as_deref() {
builder = builder.host_id_override(host_id);
}
let input = ReportInput {
profile: builder.build_with_control(&budget)?,
context: ReportContext::Connected {
cookie: self.args.cookie.clone(),
client_ip: self.args.client_ip.clone(),
client_ipv6: self.args.client_ipv6.clone(),
md5: self.args.md5.clone(),
},
};
println!("{}", generate_report_with_control(&input, &budget)?);
let cookie_params = self.parse_cookie();
let report = self.generate_hip_report(&cookie_params)?;
debug!("Generated HIP report:\n{}", report);
println!("{}", report);
Ok(())
}
fn parse_cookie(&self) -> HashMap<String, String> {
// Parse URL-encoded cookie string using serde_urlencoded
serde_urlencoded::from_str(&self.args.cookie).unwrap_or_default()
}
/// Generate the complete HIP report XML
fn generate_hip_report(&self, cookie_params: &HashMap<String, String>) -> anyhow::Result<String> {
let (generate_time, day, month, year) = get_current_time_components();
let user_name = cookie_params.get("user").map(|s| s.as_str()).unwrap_or("");
let host_info = self.collect_host_info(cookie_params);
let template = HipReportTemplate {
client_version: &self.args.client_version,
generate_time,
day,
month,
year,
user_name,
host_info,
md5: &self.args.md5,
};
let report = template.render()?;
format_xml(&report)
}
/// Collect host information using the configured OsProfile.
fn collect_host_info(&self, cookie_params: &'a HashMap<String, String>) -> HostInfo {
HostInfoCollector::new(&self.profile, self.args, cookie_params).collect()
}
}
/// Construct an `OsProfile` from CLI args, falling back to per-OS defaults
/// for any value not supplied on the command line.
fn build_os_profile(args: &HipArgs) -> OsProfile {
let client_os = ClientOs::from(args.client_os);
let mut builder = OsProfileBuilder::new(client_os).client_version(args.client_version.clone());
if let Some(host_id) = args.host_id.as_deref() {
debug!("HIP host-id override supplied: {}", host_id);
builder = builder.host_id_override(host_id);
}
let profile = builder.build();
debug!(
"HIP OS profile host-id: runtime={}, projected={}, client_os={}",
profile.host_identity().host_id(),
profile.host_id(),
client_os.as_str()
);
profile
}
// ============================================================================
// Host Information Collector
// ============================================================================
/// Helper struct for collecting host information.
///
/// Identity values (vendor, host_id, computer name, software version) come
/// from the configured `OsProfile`, while runtime state (network interfaces,
/// IP addresses) is enumerated here from the underlying machine.
struct HostInfoCollector<'p, 'a> {
profile: &'p OsProfile,
args: &'a HipArgs,
cookie_params: &'a HashMap<String, String>,
}
impl<'p, 'a> HostInfoCollector<'p, 'a> {
fn new(profile: &'p OsProfile, args: &'a HipArgs, cookie_params: &'a HashMap<String, String>) -> Self {
Self {
profile,
args,
cookie_params,
}
}
/// Domain belongs to the runtime user/session, not the simulated OS, so
/// it is sourced from the auth cookie when available.
fn get_domain(&self) -> String {
self
.cookie_params
.get("domain")
.map(|s| s.to_string())
.unwrap_or_default()
}
/// Collect network interface information with fallback
fn collect_network_interface(&self) -> NetworkInterface {
match netdev::get_default_interface() {
Ok(iface) => NetworkInterface::new(
iface.name.clone(),
iface.description.unwrap_or_else(|| iface.name.clone()),
)
.with_mac(iface.mac_addr.map(|mac| mac.address()))
.with_ipv4(iface.ipv4.first().map(|ip| ip.addr().to_string()))
.with_ipv6(iface.ipv6.first().map(|ip| ip.addr().to_string())),
Err(_) => NetworkInterface::new("unknown".to_string(), "unknown".to_string())
.with_ipv4(self.args.client_ip.clone())
.with_ipv6(self.args.client_ipv6.clone()),
}
}
/// Single entry point for collecting host info — dispatches per-OS
/// behavior via `OsProfile` methods rather than `#[cfg(target_os)]`.
fn collect(&self) -> HostInfo {
let runtime_iface = self.collect_network_interface();
let primary = self.adapt_primary_interface(&runtime_iface);
let mut interfaces = vec![primary.clone()];
interfaces.extend(self.extra_interfaces(&primary));
HostInfo {
os_vendor: self.profile.os_vendor().to_string(),
os_version: self.profile.os_version().to_string(),
host_id: self.profile.host_id().to_string(),
host_name: self.profile.computer().to_string(),
software_version: self.profile.software_version().to_string(),
domain: self.domain_for_profile(),
network_interfaces: interfaces,
defender: self.defender_for_profile(),
}
}
/// Build the primary network interface with OS-appropriate naming and
/// MAC formatting. When emulating a different OS, the runtime interface
/// name/description are replaced with the canonical placeholder for the
/// target OS.
fn adapt_primary_interface(&self, runtime: &NetworkInterface) -> NetworkInterface {
let (name, description) = if self.profile.is_native() {
(runtime.name.clone(), runtime.description.clone())
} else {
placeholder_interface_for(self.profile, runtime)
};
NetworkInterface {
name,
description,
mac_address: format_mac_for(self.profile, runtime.mac_address.clone()),
ipv4: runtime.ipv4.clone(),
ipv6: runtime.ipv6.clone(),
}
}
/// Additional interfaces appended after the primary. Only Windows
/// emits the software loopback interface in HIP reports.
fn extra_interfaces(&self, primary: &NetworkInterface) -> Vec<NetworkInterface> {
match self.profile.client_os() {
ClientOs::Windows => vec![NetworkInterface {
name: derive_windows_network_name(self.profile.host_id(), primary),
description: "Software Loopback Interface 1".to_string(),
mac_address: Some(String::new()),
ipv4: Some("127.0.0.1".to_string()),
ipv6: Some("::1".to_string()),
}],
ClientOs::Linux | ClientOs::Mac => vec![],
}
}
/// Linux HIP reports omit the domain field; macOS/Windows include it
/// from the auth cookie.
fn domain_for_profile(&self) -> String {
match self.profile.client_os() {
ClientOs::Linux => String::new(),
ClientOs::Mac | ClientOs::Windows => self.get_domain(),
}
}
fn defender_for_profile(&self) -> Option<DefenderInfo> {
match self.profile.client_os() {
ClientOs::Linux => detect_microsoft_defender_blocking(),
ClientOs::Mac | ClientOs::Windows => None,
}
}
}
fn detect_microsoft_defender_blocking() -> Option<DefenderInfo> {
let output = Command::new("mdatp")
.arg("health")
.arg("--output")
.arg("json")
.output()
.ok()?;
if !output.status.success() {
debug!("mdatp health command failed");
return None;
}
let json = String::from_utf8(output.stdout).ok()?;
let defender = parse_defender_info(&json)?;
debug!("Detected Microsoft Defender: {:?}", defender);
Some(defender)
}
fn parse_defender_info(json: &str) -> Option<DefenderInfo> {
serde_json::from_str(json).ok()
}
// ============================================================================
// Per-OS interface helpers (selected via OsProfile, not cfg)
// ============================================================================
/// Canonical interface name/description for the target OS when the runtime
/// is a different OS (i.e. emulation).
fn placeholder_interface_for(profile: &OsProfile, runtime: &NetworkInterface) -> (String, String) {
match profile.client_os() {
ClientOs::Linux => ("enp1s0f0".to_string(), "enp1s0f0".to_string()),
ClientOs::Mac => ("en0".to_string(), "en0".to_string()),
ClientOs::Windows => (
derive_windows_network_name(profile.host_id(), runtime),
"PANGP Virtual Ethernet Adapter Secure".to_string(),
),
}
}
/// MAC address formatting per target OS. Windows uses hyphen separators;
/// Linux and macOS preserve the colon-separated form returned by the
/// platform.
fn format_mac_for(profile: &OsProfile, mac: Option<String>) -> Option<String> {
match profile.client_os() {
ClientOs::Windows => mac.map(|m| m.replace(':', "-")),
ClientOs::Linux | ClientOs::Mac => mac,
}
}
// ============================================================================
// Utility Functions
// ============================================================================
/// Get current time components for HIP report
fn get_current_time_components() -> (String, String, String, String) {
let now = chrono::Local::now();
(
now.format("%m/%d/%Y %H:%M:%S").to_string(),
now.format("%d").to_string(),
now.format("%m").to_string(),
now.format("%Y").to_string(),
)
}
/// Format XML string with proper indentation
fn format_xml(xml_str: &str) -> anyhow::Result<String> {
let xml = Element::parse(xml_str.as_bytes())?;
let config = xmltree::EmitterConfig::new().perform_indent(true);
let mut xml_buf = Vec::new();
xml.write_with_config(&mut xml_buf, config)?;
Ok(String::from_utf8(xml_buf)?)
}
fn derive_windows_network_name(host_id: &str, iface: &NetworkInterface) -> String {
let seed = format!(
"{}-{}-{}",
host_id,
iface.mac_address.as_deref().unwrap_or("00:00:00:00:00:00"),
iface.name
);
format!(
"{{{}}}",
uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_DNS, seed.as_bytes())
.to_string()
.to_uppercase()
)
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::os_profile::runtime_client_os;
fn make_hip_args(client_os: Os) -> HipArgs {
HipArgs {
client_version: "6.2.4-49".to_string(),
client_os,
os_version: Some("test-os-version".to_string()),
host_id: None,
cookie: String::new(),
client_ip: None,
client_ipv6: None,
md5: "deadbeef".to_string(),
}
}
fn make_profile(client_os: ClientOs) -> OsProfile {
OsProfileBuilder::new(client_os).build()
}
#[test]
fn host_info_os_vendor_is_linux_for_linux_profile() {
let args = make_hip_args(Os::Linux);
let profile = make_profile(ClientOs::Linux);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_vendor, "Linux");
}
#[test]
fn host_info_os_vendor_is_apple_for_mac_profile() {
let args = make_hip_args(Os::Mac);
let profile = make_profile(ClientOs::Mac);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_vendor, "Apple");
}
#[test]
fn host_info_os_vendor_is_microsoft_for_windows_profile() {
let args = make_hip_args(Os::Windows);
let profile = make_profile(ClientOs::Windows);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_vendor, "Microsoft");
}
#[test]
fn host_info_host_id_comes_from_os_profile() {
let args = make_hip_args(Os::Linux);
let profile = make_profile(ClientOs::Linux);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.host_id, profile.host_id());
}
#[test]
fn host_info_host_id_independent_of_runtime_for_each_os() {
// host_id should reflect the OsProfile's machine identity for every
// simulated OS, regardless of the runtime platform.
for (client_os, os_arg) in [
(ClientOs::Linux, Os::Linux),
(ClientOs::Mac, Os::Mac),
(ClientOs::Windows, Os::Windows),
] {
let args = make_hip_args(os_arg);
let profile = make_profile(client_os);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.host_id, profile.host_id());
}
}
#[test]
fn hip_os_version_argument_is_ignored() {
let args = make_hip_args(Os::Linux);
let profile = build_os_profile(&args);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(info.os_version, profile.os_version());
assert_ne!(info.os_version, "test-os-version");
}
#[test]
fn host_id_argument_sets_profile_runtime_identity() {
let mut args = make_hip_args(Os::default());
args.host_id = Some("auth-host-id".to_string());
let profile = build_os_profile(&args);
assert_eq!(profile.client_os(), runtime_client_os());
assert_eq!(profile.host_identity().host_id(), "auth-host-id");
}
#[test]
fn host_info_uses_host_id_argument_for_native_profile() {
let mut args = make_hip_args(Os::default());
args.host_id = Some("auth-host-id".to_string());
let profile = build_os_profile(&args);
let cookie_params: HashMap<String, String> = HashMap::new();
let info = HostInfoCollector::new(&profile, &args, &cookie_params).collect();
assert_eq!(profile.host_identity().host_id(), "auth-host-id");
assert_eq!(info.host_id, profile.host_id());
}
#[test]
fn parses_microsoft_defender_health_json() {
let defender = parse_defender_info(
r#"{
"appVersion": "101.25042.0000",
"engineVersion": "1.1.25040.2",
"definitionsVersion": "1.429.201.0",
"realTimeProtectionEnabled": { "value": true }
}"#,
)
.expect("defender health json should parse");
assert_eq!(defender.app_version, "101.25042.0000");
assert_eq!(defender.engine_version, "1.1.25040.2");
assert_eq!(defender.definitions_version, "1.429.201.0");
assert!(defender.real_time_protection_enabled.value);
}
#[test]
fn rejects_invalid_microsoft_defender_health_json() {
assert!(parse_defender_info("{}").is_none());
}
}
+20 -3
View File
@@ -1,4 +1,4 @@
use std::{fs, path::PathBuf};
use std::{collections::HashMap, fs, path::PathBuf};
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
use std::process::{Command, ExitStatus};
@@ -11,7 +11,10 @@ use clap::Args;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
use common::binary_paths;
use directories::ProjectDirs;
use gpapi::{process::desktop_launcher::DesktopLauncher, utils::endpoint::http_endpoint};
use gpapi::{
process::service_launcher::ServiceLauncher,
utils::{endpoint::http_endpoint, env_utils, shutdown_signal},
};
use log::info;
#[derive(Args)]
@@ -66,13 +69,27 @@ impl<'a> LaunchGuiHandler<'a> {
return Ok(());
}
tokio::spawn(async move {
shutdown_signal().await;
info!("Shutting down...");
});
let log_file = get_log_file()?;
let log_file_path = log_file.to_string_lossy().to_string();
info!("Log file: {}", log_file_path);
let exit_status = DesktopLauncher::new(env!("CARGO_PKG_VERSION"))
let mut extra_envs = HashMap::<String, String>::new();
extra_envs.insert("GP_LOG_FILE".into(), log_file_path.clone());
// Persist the environment variables to a file
let env_file = env_utils::persist_env_vars(Some(extra_envs))?;
let env_file = env_file.into_temp_path();
let env_file_path = env_file.to_string_lossy().to_string();
let exit_status = ServiceLauncher::new()
.minimized(self.args.minimized)
.env_file(&env_file_path)
.log_file(&log_file_path)
.launch()
.await?;
@@ -139,15 +139,6 @@
{% elif host_info.os_vendor == "Apple" -%}
<entry name="anti-malware">
<list>
{% if let Some(sentinel) = &host_info.sentinel %}
<entry>
<ProductInfo>
<Prod vendor="SentinelOne" name="Sentinel Agent" version="{{ sentinel.version }}" engver="" datemon="{{ month }}" dateday="{{ day }}" dateyear="{{ year }}" prodType="3" osType="4"/>
<real-time-protection>{% if sentinel.real_time_protection %}yes{% else %}no{% endif %}</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
{% endif -%}
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="Xprotect" version="2167" defver="235000000000000" engver="" datemon="{{ month }}" dateday="{{ day }}" dateyear="{{ year }}" prodType="3" osType="4"/>
@@ -199,16 +190,6 @@
</entry>
<entry name="firewall">
<list>
{% if let Some(sentinel) = &host_info.sentinel %}
{% if let Some(firewall_enabled) = sentinel.firewall_enabled %}
<entry>
<ProductInfo>
<Prod vendor="SentinelOne" name="Sentinel Agent" version="{{ sentinel.version }}"/>
<is-enabled>{% if firewall_enabled %}yes{% else %}no{% endif %}</is-enabled>
</ProductInfo>
</entry>
{% endif -%}
{% endif -%}
<entry>
<ProductInfo>
<Prod vendor="Apple Inc." name="Mac OS X Builtin Firewall" version="{{ host_info.software_version }}"/>
@@ -237,17 +218,8 @@
</entry>
{% elif host_info.os_vendor == "Linux" -%}
<entry name="anti-malware">
{% if let Some(defender) = &host_info.defender -%}
<list>
{% if let Some(sentinel) = &host_info.sentinel %}
<entry>
<ProductInfo>
<Prod vendor="SentinelOne" name="Sentinel Agent" version="{{ sentinel.version }}" engver="" datemon="{{ month }}" dateday="{{ day }}" dateyear="{{ year }}" prodType="3" osType="1"/>
<real-time-protection>{% if sentinel.real_time_protection %}yes{% else %}no{% endif %}</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
{% endif -%}
{% if let Some(defender) = &host_info.defender %}
<entry>
<ProductInfo>
<Prod name="Microsoft Defender ATP" version="{{ defender.app_version }}" defver="{{ defender.definitions_version }}" prodType="3" engver="{{ defender.engine_version }}" osType="1" vendor="Microsoft Corporation" dateday="{{ day }}" dateyear="{{ year }}" datemon="{{ month }}">
@@ -256,17 +228,10 @@
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
{% endif -%}
{% if let Some(clamav) = &host_info.clamav %}
<entry>
<ProductInfo>
<Prod vendor="Cisco Systems, Inc." name="ClamAV" version="{{ clamav.version }}"{% if let Some(definitions_version) = &clamav.definitions_version %} defver="{{ definitions_version }}"{% endif %} engver="" datemon="{{ month }}" dateday="{{ day }}" dateyear="{{ year }}" prodType="3" osType="1"/>
<real-time-protection>{% if clamav.real_time_protection %}yes{% else %}no{% endif %}</real-time-protection>
<last-full-scan-time>n/a</last-full-scan-time>
</ProductInfo>
</entry>
{% endif -%}
</list>
{% else -%}
<list/>
{% endif -%}
</entry>
<entry name="disk-backup">
<list/>
@@ -289,14 +254,6 @@
</entry>
<entry name="firewall">
<list>
{% if let Some(ufw) = &host_info.ufw %}
<entry>
<ProductInfo>
<Prod vendor="Canonical Ltd." name="UFW" version="{{ ufw.version }}"/>
<is-enabled>{% if ufw.is_enabled %}yes{% else %}no{% endif %}</is-enabled>
</ProductInfo>
</entry>
{% endif -%}
<entry>
<ProductInfo>
<Prod name="IPTables" version="1.8.4" vendor="IPTables">
-9
View File
@@ -1,9 +0,0 @@
var e=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports);(function(){let e=document.createElement(`link`).relList;if(e&&e.supports&&e.supports(`modulepreload`))return;for(let e of document.querySelectorAll(`link[rel="modulepreload"]`))n(e);new MutationObserver(e=>{for(let t of e)if(t.type===`childList`)for(let e of t.addedNodes)e.tagName===`LINK`&&e.rel===`modulepreload`&&n(e)}).observe(document,{childList:!0,subtree:!0});function t(e){let t={};return e.integrity&&(t.integrity=e.integrity),e.referrerPolicy&&(t.referrerPolicy=e.referrerPolicy),t.credentials=e.crossOrigin===`use-credentials`?`include`:e.crossOrigin===`anonymous`?`omit`:`same-origin`,t}function n(e){if(e.ep)return;e.ep=!0;let n=t(e);fetch(e.href,n)}})();var t=e((e=>{function t(e,t){var n=e.length;e.push(t);a:for(;0<n;){var r=n-1>>>1,a=e[r];if(0<i(a,t))e[r]=t,e[n]=a,n=r;else break a}}function n(e){return e.length===0?null:e[0]}function r(e){if(e.length===0)return null;var t=e[0],n=e.pop();if(n!==t){e[0]=n;a:for(var r=0,a=e.length,o=a>>>1;r<o;){var s=2*(r+1)-1,c=e[s],l=s+1,u=e[l];if(0>i(c,n))l<a&&0>i(u,c)?(e[r]=u,e[l]=n,r=l):(e[r]=c,e[s]=n,r=s);else if(l<a&&0>i(u,n))e[r]=u,e[l]=n,r=l;else break a}}return t}function i(e,t){var n=e.sortIndex-t.sortIndex;return n===0?e.id-t.id:n}if(e.unstable_now=void 0,typeof performance==`object`&&typeof performance.now==`function`){var a=performance;e.unstable_now=function(){return a.now()}}else{var o=Date,s=o.now();e.unstable_now=function(){return o.now()-s}}var c=[],l=[],u=1,d=null,f=3,p=!1,m=!1,h=!1,g=!1,_=typeof setTimeout==`function`?setTimeout:null,v=typeof clearTimeout==`function`?clearTimeout:null,y=typeof setImmediate<`u`?setImmediate:null;function b(e){for(var i=n(l);i!==null;){if(i.callback===null)r(l);else if(i.startTime<=e)r(l),i.sortIndex=i.expirationTime,t(c,i);else break;i=n(l)}}function ee(e){if(h=!1,b(e),!m){if(n(c)!==null)m=!0,x||(x=!0,ie());else{var t=n(l);t!==null&&se(ee,t.startTime-e)}}}var x=!1,te=-1,ne=5,S=-1;function re(){return g?!0:!(e.unstable_now()-S<ne)}function C(){if(g=!1,x){var t=e.unstable_now();S=t;var i=!0;try{a:{m=!1,h&&(h=!1,v(te),te=-1),p=!0;var a=f;try{b:{for(b(t),d=n(c);d!==null&&!(d.expirationTime>t&&re());){var o=d.callback;if(typeof o==`function`){d.callback=null,f=d.priorityLevel;var s=o(d.expirationTime<=t);if(t=e.unstable_now(),typeof s==`function`){d.callback=s,b(t),i=!0;break b}d===n(c)&&r(c),b(t)}else r(c);d=n(c)}if(d!==null)i=!0;else{var u=n(l);u!==null&&se(ee,u.startTime-t),i=!1}}break a}finally{d=null,f=a,p=!1}i=void 0}}finally{i?ie():x=!1}}}var ie;if(typeof y==`function`)ie=function(){y(C)};else if(typeof MessageChannel<`u`){var ae=new MessageChannel,oe=ae.port2;ae.port1.onmessage=C,ie=function(){oe.postMessage(null)}}else ie=function(){_(C,0)};function se(t,n){te=_(function(){t(e.unstable_now())},n)}e.unstable_IdlePriority=5,e.unstable_ImmediatePriority=1,e.unstable_LowPriority=4,e.unstable_NormalPriority=3,e.unstable_Profiling=null,e.unstable_UserBlockingPriority=2,e.unstable_cancelCallback=function(e){e.callback=null},e.unstable_forceFrameRate=function(e){0>e||125<e?console.error(`forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported`):ne=0<e?Math.floor(1e3/e):5},e.unstable_getCurrentPriorityLevel=function(){return f},e.unstable_next=function(e){switch(f){case 1:case 2:case 3:var t=3;break;default:t=f}var n=f;f=t;try{return e()}finally{f=n}},e.unstable_requestPaint=function(){g=!0},e.unstable_runWithPriority=function(e,t){switch(e){case 1:case 2:case 3:case 4:case 5:break;default:e=3}var n=f;f=e;try{return t()}finally{f=n}},e.unstable_scheduleCallback=function(r,i,a){var o=e.unstable_now();switch(typeof a==`object`&&a?(a=a.delay,a=typeof a==`number`&&0<a?o+a:o):a=o,r){case 1:var s=-1;break;case 2:s=250;break;case 5:s=1073741823;break;case 4:s=1e4;break;default:s=5e3}return s=a+s,r={id:u++,callback:i,priorityLevel:r,startTime:a,expirationTime:s,sortIndex:-1},a>o?(r.sortIndex=a,t(l,r),n(c)===null&&r===n(l)&&(h?(v(te),te=-1):h=!0,se(ee,a-o))):(r.sortIndex=s,t(c,r),m||p||(m=!0,x||(x=!0,ie()))),r},e.unstable_shouldYield=re,e.unstable_wrapCallback=function(e){var t=f;return function(){var n=f;f=t;try{return e.apply(this,arguments)}finally{f=n}}}})),n=e(((e,n)=>{n.exports=t()})),r=e((e=>{var t=Symbol.for(`react.transitional.element`),n=Symbol.for(`react.portal`),r=Symbol.for(`react.fragment`),i=Symbol.for(`react.strict_mode`),a=Symbol.for(`react.profiler`),o=Symbol.for(`react.consumer`),s=Symbol.for(`react.context`),c=Symbol.for(`react.forward_ref`),l=Symbol.for(`react.suspense`),u=Symbol.for(`react.memo`),d=Symbol.for(`react.lazy`),f=Symbol.for(`react.activity`),p=Symbol.for(`react.view_transition`),m=Symbol.iterator;function h(e){return typeof e!=`object`||!e?null:(e=m&&e[m]||e[`@@iterator`],typeof e==`function`?e:null)}var g={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},_=Object.assign,v={};function y(e,t,n){Line truncated
at`)?` (<anonymous>)`:-1<e.stack.indexOf(`@`)?`@unknown:0:0`:``}return`
`+ze+e+Be}var He=!1;function Ue(e,t){if(!e||He)return``;He=!0;var n=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{var r={DetermineComponentFrameRoot:function(){try{if(t){var n=function(){throw Error()};if(Object.defineProperty(n.prototype,"props",{set:function(){throw Error()}}),typeof Reflect==`object`&&Reflect.construct){try{Reflect.construct(n,[])}catch(e){var r=e}Reflect.construct(e,[],n)}else{try{n.call()}catch(e){r=e}n=!1;try{var i=Object.getOwnPropertyDescriptor(e.prototype,`props`);Object.defineProperty(e.prototype,"props",{configurable:!0,set:function(){throw Error()}}),n=!0,new e}finally{n&&(i===void 0?delete e.prototype.props:Object.defineProperty(e.prototype,"props",i))}}}else{try{throw Error()}catch(e){r=e}(n=e())&&typeof n.catch==`function`&&n.catch(function(){})}}catch(e){if(e&&r&&typeof e.stack==`string`)return[e.stack,r.stack]}return[null,null]}};r.DetermineComponentFrameRoot.displayName=`DetermineComponentFrameRoot`;var i=Object.getOwnPropertyDescriptor(r.DetermineComponentFrameRoot,`name`);i&&i.configurable&&Object.defineProperty(r.DetermineComponentFrameRoot,"name",{value:`DetermineComponentFrameRoot`});var a=r.DetermineComponentFrameRoot(),o=a[0],s=a[1];if(o&&s){var c=o.split(`
`),l=s.split(`
`);for(i=r=0;r<c.length&&!c[r].includes(`DetermineComponentFrameRoot`);)r++;for(;i<l.length&&!l[i].includes(`DetermineComponentFrameRoot`);)i++;if(r===c.length||i===l.length)for(r=c.length-1,i=l.length-1;1<=r&&0<=i&&c[r]!==l[i];)i--;for(;1<=r&&0<=i;r--,i--)if(c[r]!==l[i]){if(r!==1||i!==1)do if(r--,i--,0>i||c[r]!==l[i]){var u=`
`+c[r].replace(` at new `,` at `);return e.displayName&&u.includes(`<anonymous>`)&&(u=u.replace(`<anonymous>`,e.displayName)),u}while(1<=r&&0<=i);break}}}finally{He=!1,Error.prepareStackTrace=n}return(n=e?e.displayName||e.name:``)?Ve(n):``}function We(e,t){switch(e.tag){case 26:case 27:case 5:return Ve(e.type);case 16:return Ve(`Lazy`);case 13:return e.child!==t&&t!==null?Ve(`Suspense Fallback`):Ve(`Suspense`);case 19:return Ve(`SuspenseList`);case 0:case 15:return Ue(e.type,!1);case 11:return Ue(e.type.render,!1);case 1:return Ue(e.type,!0);case 31:return Ve(`Activity`);case 30:return Ve(`ViewTransition`);default:return``}}function Ge(e){try{var t=``,n=null;do t+=We(e,n),n=e,e=e.return;while(e);return t}catch(e){return`
Error generating stack: `+e.message+`
`+e.stack}}var Ke=Object.prototype.hasOwnProperty,qe=t.unstable_scheduleCallback,Je=t.unstable_cancelCallback,Ye=t.unstable_shouldYield,Xe=t.unstable_requestPaint,Ze=t.unstable_now,Qe=t.unstable_getCurrentPriorityLevel,$e=t.unstable_ImmediatePriority,et=t.unstable_UserBlockingPriority,tt=t.unstable_NormalPriority,nt=t.unstable_LowPriority,rt=t.unstable_IdlePriority,it=t.log,at=t.unstable_setDisableYieldValue,ot=null,st=null;function ct(e){if(typeof it==`function`&&at(e),st&&typeof st.setStrictMode==`function`)try{st.setStrictMode(ot,e)}catch{}}var lt=Math.clz32?Math.clz32:ft,ut=Math.log,dt=Math.LN2;function ft(e){return e>>>=0,e===0?32:31-(ut(e)/dt|0)|0}var pt=256,mt=262144,ht=4194304;function gt(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:return e&-e;case 262144:case 524288:case 1048576:case 2097152:return e&3932160;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function _t(e,t,n){var r=e.pendingLanes;if(r===0)return 0;var i=0,a=e.suspendedLanes,o=e.pingedLanes;e=e.warmLanes;var s=r&134217727;return s===0?(s=r&~a,s===0?o===0?n||(n=r&~e,n!==0&&(i=gt(n))):i=gt(o):i=gt(s)):(r=s&~a,r===0?(o&=s,o===0?n||(n=s&~e,n!==0&&(i=gt(n))):i=gt(o)):i=gt(r)),i===0?0:t!==0&&t!==i&&(t&a)===0&&(a=i&-i,n=t&-t,a>=n||a===32&&n&4194048)?t:i}function vt(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function yt(e,t){t&8&&(t|=t&32);var n=e.entangledLanes;if(n!==0)for(e=e.entanglements,n&=t;0<n;){var r=31-lt(n),i=1<<r;t|=e[r],n&=~i}return t}function bt(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function xt(){var e=ht;return ht<<=1,!(ht&62914560)&&(ht=4194304),e}function St(e){for(var t=[],n=0;31>n;n++)t.push(e);return t}function Ct(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function wt(e,t,n,r,i,a){var o=e.pendingLanes;e.pendingLanes=n,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=n,e.entangledLanes&=n,e.errorRecoveryDisabledLanes&=n,e.shellSuspendCounter=0;var s=e.entanglements,c=e.expirationTimes,l=e.hiddenUpdates;for(n=o&~n;0<n;){var u=31-lt(n),d=1<<u;s[u]=0,c[u]=-1;var f=l[u];if(f!==null)for(l[u]=null,u=0;u<f.length;u++){var p=f[u];p!==null&&(p.lane&=-536870913)}n&=~d}r!==0&&Tt(e,r,0),a!==0&&i===0&&e.tag!==0&&(e.suspendedLanes|=a&~(o&~t))}function Tt(e,t,n){e.pendingLanes|=t,e.suspendedLanes&=~t;var r=31-lt(t);e.entangledLanes|=t,e.entanglements[r]=e.entanglements[r]|1073741824|n&261930}function Et(e,t){var n=e.entangledLanes|=t;for(e=e.entanglements;n;){var r=31-lt(n),i=1<<r;i&t|e[r]&t&&(e[r]|=t),n&=~i}}function Dt(e,t){var n=t&-t;return n=n&42?1:Ot(n),(n&(e.suspendedLanes|t))===0?n:0}function Ot(e){switch(e){case 2:e=1;break;case 8:e=4;break;case 32:e=16;break;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:e=128;break;case 268435456:e=134217728;break;default:e=0}return e}function kt(e){return e&=-e,2<e?8<e?e&134217727?32:268435456:8:2}function At(){var e=E.p;return e===0?(e=window.event,e===void 0?32:Ch(e.type)):e}function jt(e,t){var n=E.p;try{return E.p=e,t()}finally{E.p=n}}var Mt=Math.random().toString(36).slice(2),Nt=`__reactFiber$`+Mt,Pt=`__reactProps$`+Mt,Ft=`__reactContainer$`+Mt,It=`__reactEvents$`+Mt,Lt=`__reactListeners$`+Mt,Rt=`__reactHandles$`+Mt,zt=`__reactResources$`+Mt,Bt=`__reactMarker$`+Mt,Vt=`__reactLoad$`+Mt;function Ht(e){delete e[Nt],delete e[Pt],delete e[Lt],delete e[Rt]}function Ut(e){var t;if(t=e[Nt])return t;for(var n=e.parentNode;n;){if(t=n[Ft]||n[Nt]){if(n=t.alternate,t.child!==null||n!==null&&n.child!==null)for(e=fm(e);e!==null;){if(n=e[Nt])return n;e=fm(e)}return t}e=n,n=e.parentNode}return null}function Wt(e){if(e=e[Nt]||e[Ft]){var t=e.tag;if(t===5||t===6||t===13||t===31||t===26||t===27||t===3)return e}return null}function Gt(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e.stateNode;throw Error(s(33))}function Kt(e){var t=e[zt];return t||=e[zt]={hoistableStyles:new Map,hoistableScripts:new Map},t}function qt(e){e[Bt]=!0}function Jt(e){e[Vt]=void 0}var Yt=new Set,Xt={};function Zt(e,t){Qt(e,t),Qt(e+`Capture`,t)}function Qt(e,t){for(Xt[e]=t,e=0;e<t.le Line truncated
`).replace(Qf,``)}function ep(e,t){return t=$f(t),$f(e)===t}function $(e,t,n,r,i,a){switch(n){case`children`:if(typeof r==`string`)t===`body`||t===`textarea`&&r===``||xn(e,r);else if(typeof r==`number`||typeof r==`bigint`)t!==`body`&&xn(e,``+r);else return;break;case`className`:on(e,`class`,r);break;case`tabIndex`:on(e,`tabindex`,r);break;case`dir`:case`role`:case`viewBox`:case`width`:case`height`:on(e,n,r);break;case`style`:wn(e,r,a);return;case`data`:if(t!==`object`){on(e,`data`,r);break}case`src`:case`href`:if(r===``&&(t!==`a`||n!==`href`)){e.removeAttribute(n);break}if(r==null||typeof r==`function`||typeof r==`symbol`||typeof r==`boolean`){e.removeAttribute(n);break}r=On(r),e.setAttribute(n,r);break;case`action`:case`formAction`:if(typeof r==`function`){e.setAttribute(n,`javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')`);break}if(typeof a==`function`&&(n===`formAction`?(t!==`input`&&$(e,t,`name`,i.name,i,null),$(e,t,`formEncType`,i.formEncType,i,null),$(e,t,`formMethod`,i.formMethod,i,null),$(e,t,`formTarget`,i.formTarget,i,null)):($(e,t,`encType`,i.encType,i,null),$(e,t,`method`,i.method,i,null),$(e,t,`target`,i.target,i,null))),r==null||typeof r==`symbol`||typeof r==`boolean`){e.removeAttribute(n);break}r=On(r),e.setAttribute(n,r);break;case`onClick`:r!=null&&(e.onclick=kn);return;case`onScroll`:r!=null&&Q(`scroll`,e);return;case`onScrollEnd`:r!=null&&Q(`scrollend`,e);return;case`dangerouslySetInnerHTML`:if(r!=null){if(typeof r!=`object`||!(`__html`in r))throw Error(s(61));if(n=r.__html,n!=null){if(i.children!=null)throw Error(s(60));a?.__html!==n&&(e.innerHTML=n)}}break;case`multiple`:e.multiple=r&&typeof r!=`function`&&typeof r!=`symbol`;break;case`muted`:e.muted=r&&typeof r!=`function`&&typeof r!=`symbol`;break;case`suppressContentEditableWarning`:case`suppressHydrationWarning`:case`defaultValue`:case`defaultChecked`:case`innerHTML`:case`ref`:break;case`autoFocus`:break;case`xlinkHref`:if(r==null||typeof r==`function`||typeof r==`boolean`||typeof r==`symbol`){e.removeAttribute(`xlink:href`);break}n=On(r),e.setAttributeNS(`http://www.w3.org/1999/xlink`,`xlink:href`,n);break;case`contentEditable`:case`spellCheck`:case`draggable`:case`value`:case`autoReverse`:case`externalResourcesRequired`:case`focusable`:case`preserveAlpha`:r!=null&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,r):e.removeAttribute(n);break;case`inert`:case`allowFullScreen`:case`async`:case`autoPlay`:case`controls`:case`credentialless`:case`default`:case`defer`:case`disabled`:case`disablePictureInPicture`:case`disableRemotePlayback`:case`formNoValidate`:case`hidden`:case`loop`:case`noModule`:case`noValidate`:case`open`:case`playsInline`:case`readOnly`:case`required`:case`reversed`:case`scoped`:case`seamless`:case`itemScope`:r&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,``):e.removeAttribute(n);break;case`capture`:case`download`:!0===r?e.setAttribute(n,``):!1!==r&&r!=null&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,r):e.removeAttribute(n);break;case`cols`:case`rows`:case`size`:case`span`:r!=null&&typeof r!=`function`&&typeof r!=`symbol`&&!isNaN(r)&&1<=r?e.setAttribute(n,r):e.removeAttribute(n);break;case`rowSpan`:case`start`:r==null||typeof r==`function`||typeof r==`symbol`||isNaN(r)?e.removeAttribute(n):e.setAttribute(n,r);break;case`popover`:Q(`beforetoggle`,e),Q(`toggle`,e),an(e,`popover`,r);break;case`xlinkActuate`:sn(e,`http://www.w3.org/1999/xlink`,`xlink:actuate`,r);break;case`xlinkArcrole`:sn(e,`http://www.w3.org/1999/xlink`,`xlink:arcrole`,r);break;case`xlinkRole`:sn(e,`http://www.w3.org/1999/xlink`,`xlink:role`,r);break;case`xlinkShow`:sn(e,`http://www.w3.org/1999/xlink`,`xlink:show`,r);break;case`xlinkTitle`:sn(e,`http://www.w3.org/1999/xlink`,`xlink:title`,r);break;case`xlinkType`:sn(e,`http://www.w3.org/1999/xlink`,`xlink:type`,r);break;case`xmlBase`:sn(e,`http://www.w3.org/XML/1998/namespace`,`xml:base`,r);break;case`xmlLang`:sn(e,`http://www.w3.org/XML/1998/namespace`,`xml:lang`,r);break;case`xmlSpace`:sn(e,`http://www.w3.org/XML/1998/namespace`,`xml:space`,r);break;case`is`:an(e,`is`,r);break;case`innerText`:case`textContent`:return;default:if(!(2<n.length)||n[0]!==`o`&&n[0]!==`O`||n[1]!==`n`&&n[1]!==`N`)n=En.get(n)||n,an(e,n,r);else return}O=!0}function tp(e,t,n,r,i,a){switch(n){case`style`:wn(e,r,a);return;case`dangerouslySetInnerHTML`:if(r!=null){if(typeof r!=`object`||!(`__html`in r))throw Error(s(61));if(n=r.__html,n!=null){if(i.children!=null)throw Error(s(60));a?.__html!==n&&(e.innerHTML=n)}}break;case`children`:if(typeof r==`string`)xn(e,r);else if(typeof r==`number`||typeof r==`bigint`)xn(e,``+r);else return;break;case`onScroll`:r!=null&&Q(`scroll`,e);return;case`onScrollEnd`:r!=null&&Q(`scrollend`,e);return;case`onClick`:r!=null&&(e.onclick=k Line truncated
+9
View File
@@ -0,0 +1,9 @@
var e=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports);(function(){let e=document.createElement(`link`).relList;if(e&&e.supports&&e.supports(`modulepreload`))return;for(let e of document.querySelectorAll(`link[rel="modulepreload"]`))n(e);new MutationObserver(e=>{for(let t of e)if(t.type===`childList`)for(let e of t.addedNodes)e.tagName===`LINK`&&e.rel===`modulepreload`&&n(e)}).observe(document,{childList:!0,subtree:!0});function t(e){let t={};return e.integrity&&(t.integrity=e.integrity),e.referrerPolicy&&(t.referrerPolicy=e.referrerPolicy),e.crossOrigin===`use-credentials`?t.credentials=`include`:e.crossOrigin===`anonymous`?t.credentials=`omit`:t.credentials=`same-origin`,t}function n(e){if(e.ep)return;e.ep=!0;let n=t(e);fetch(e.href,n)}})();var t=e((e=>{function t(e,t){var n=e.length;e.push(t);a:for(;0<n;){var r=n-1>>>1,a=e[r];if(0<i(a,t))e[r]=t,e[n]=a,n=r;else break a}}function n(e){return e.length===0?null:e[0]}function r(e){if(e.length===0)return null;var t=e[0],n=e.pop();if(n!==t){e[0]=n;a:for(var r=0,a=e.length,o=a>>>1;r<o;){var s=2*(r+1)-1,c=e[s],l=s+1,u=e[l];if(0>i(c,n))l<a&&0>i(u,c)?(e[r]=u,e[l]=n,r=l):(e[r]=c,e[s]=n,r=s);else if(l<a&&0>i(u,n))e[r]=u,e[l]=n,r=l;else break a}}return t}function i(e,t){var n=e.sortIndex-t.sortIndex;return n===0?e.id-t.id:n}if(e.unstable_now=void 0,typeof performance==`object`&&typeof performance.now==`function`){var a=performance;e.unstable_now=function(){return a.now()}}else{var o=Date,s=o.now();e.unstable_now=function(){return o.now()-s}}var c=[],l=[],u=1,d=null,f=3,p=!1,m=!1,h=!1,g=!1,_=typeof setTimeout==`function`?setTimeout:null,v=typeof clearTimeout==`function`?clearTimeout:null,y=typeof setImmediate<`u`?setImmediate:null;function b(e){for(var i=n(l);i!==null;){if(i.callback===null)r(l);else if(i.startTime<=e)r(l),i.sortIndex=i.expirationTime,t(c,i);else break;i=n(l)}}function x(e){if(h=!1,b(e),!m)if(n(c)!==null)m=!0,S||(S=!0,re());else{var t=n(l);t!==null&&oe(x,t.startTime-e)}}var S=!1,C=-1,w=5,ee=-1;function te(){return g?!0:!(e.unstable_now()-ee<w)}function ne(){if(g=!1,S){var t=e.unstable_now();ee=t;var i=!0;try{a:{m=!1,h&&(h=!1,v(C),C=-1),p=!0;var a=f;try{b:{for(b(t),d=n(c);d!==null&&!(d.expirationTime>t&&te());){var o=d.callback;if(typeof o==`function`){d.callback=null,f=d.priorityLevel;var s=o(d.expirationTime<=t);if(t=e.unstable_now(),typeof s==`function`){d.callback=s,b(t),i=!0;break b}d===n(c)&&r(c),b(t)}else r(c);d=n(c)}if(d!==null)i=!0;else{var u=n(l);u!==null&&oe(x,u.startTime-t),i=!1}}break a}finally{d=null,f=a,p=!1}i=void 0}}finally{i?re():S=!1}}}var re;if(typeof y==`function`)re=function(){y(ne)};else if(typeof MessageChannel<`u`){var ie=new MessageChannel,ae=ie.port2;ie.port1.onmessage=ne,re=function(){ae.postMessage(null)}}else re=function(){_(ne,0)};function oe(t,n){C=_(function(){t(e.unstable_now())},n)}e.unstable_IdlePriority=5,e.unstable_ImmediatePriority=1,e.unstable_LowPriority=4,e.unstable_NormalPriority=3,e.unstable_Profiling=null,e.unstable_UserBlockingPriority=2,e.unstable_cancelCallback=function(e){e.callback=null},e.unstable_forceFrameRate=function(e){0>e||125<e?console.error(`forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported`):w=0<e?Math.floor(1e3/e):5},e.unstable_getCurrentPriorityLevel=function(){return f},e.unstable_next=function(e){switch(f){case 1:case 2:case 3:var t=3;break;default:t=f}var n=f;f=t;try{return e()}finally{f=n}},e.unstable_requestPaint=function(){g=!0},e.unstable_runWithPriority=function(e,t){switch(e){case 1:case 2:case 3:case 4:case 5:break;default:e=3}var n=f;f=e;try{return t()}finally{f=n}},e.unstable_scheduleCallback=function(r,i,a){var o=e.unstable_now();switch(typeof a==`object`&&a?(a=a.delay,a=typeof a==`number`&&0<a?o+a:o):a=o,r){case 1:var s=-1;break;case 2:s=250;break;case 5:s=1073741823;break;case 4:s=1e4;break;default:s=5e3}return s=a+s,r={id:u++,callback:i,priorityLevel:r,startTime:a,expirationTime:s,sortIndex:-1},a>o?(r.sortIndex=a,t(l,r),n(c)===null&&r===n(l)&&(h?(v(C),C=-1):h=!0,oe(x,a-o))):(r.sortIndex=s,t(c,r),m||p||(m=!0,S||(S=!0,re()))),r},e.unstable_shouldYield=te,e.unstable_wrapCallback=function(e){var t=f;return function(){var n=f;f=t;try{return e.apply(this,arguments)}finally{f=n}}}})),n=e(((e,n)=>{n.exports=t()})),r=e((e=>{var t=Symbol.for(`react.transitional.element`),n=Symbol.for(`react.portal`),r=Symbol.for(`react.fragment`),i=Symbol.for(`react.strict_mode`),a=Symbol.for(`react.profiler`),o=Symbol.for(`react.consumer`),s=Symbol.for(`react.context`),c=Symbol.for(`react.forward_ref`),l=Symbol.for(`react.suspense`),u=Symbol.for(`react.memo`),d=Symbol.for(`react.lazy`),f=Symbol.for(`react.activity`),p=Symbol.iterator;function m(e){return typeof e!=`object`||!e?null:(e=p&&e[p]||e[`@@iterator`],typeof e==`function`?e:null)}var h={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},g=Object.assign,_={};function v(e,t,n){this.props=e,this.Line truncated
at`)?` (<anonymous>)`:-1<e.stack.indexOf(`@`)?`@unknown:0:0`:``}return`
`+Se+e+Ce}var Te=!1;function Ee(e,t){if(!e||Te)return``;Te=!0;var n=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{var r={DetermineComponentFrameRoot:function(){try{if(t){var n=function(){throw Error()};if(Object.defineProperty(n.prototype,"props",{set:function(){throw Error()}}),typeof Reflect==`object`&&Reflect.construct){try{Reflect.construct(n,[])}catch(e){var r=e}Reflect.construct(e,[],n)}else{try{n.call()}catch(e){r=e}e.call(n.prototype)}}else{try{throw Error()}catch(e){r=e}(n=e())&&typeof n.catch==`function`&&n.catch(function(){})}}catch(e){if(e&&r&&typeof e.stack==`string`)return[e.stack,r.stack]}return[null,null]}};r.DetermineComponentFrameRoot.displayName=`DetermineComponentFrameRoot`;var i=Object.getOwnPropertyDescriptor(r.DetermineComponentFrameRoot,`name`);i&&i.configurable&&Object.defineProperty(r.DetermineComponentFrameRoot,"name",{value:`DetermineComponentFrameRoot`});var a=r.DetermineComponentFrameRoot(),o=a[0],s=a[1];if(o&&s){var c=o.split(`
`),l=s.split(`
`);for(i=r=0;r<c.length&&!c[r].includes(`DetermineComponentFrameRoot`);)r++;for(;i<l.length&&!l[i].includes(`DetermineComponentFrameRoot`);)i++;if(r===c.length||i===l.length)for(r=c.length-1,i=l.length-1;1<=r&&0<=i&&c[r]!==l[i];)i--;for(;1<=r&&0<=i;r--,i--)if(c[r]!==l[i]){if(r!==1||i!==1)do if(r--,i--,0>i||c[r]!==l[i]){var u=`
`+c[r].replace(` at new `,` at `);return e.displayName&&u.includes(`<anonymous>`)&&(u=u.replace(`<anonymous>`,e.displayName)),u}while(1<=r&&0<=i);break}}}finally{Te=!1,Error.prepareStackTrace=n}return(n=e?e.displayName||e.name:``)?we(n):``}function De(e,t){switch(e.tag){case 26:case 27:case 5:return we(e.type);case 16:return we(`Lazy`);case 13:return e.child!==t&&t!==null?we(`Suspense Fallback`):we(`Suspense`);case 19:return we(`SuspenseList`);case 0:case 15:return Ee(e.type,!1);case 11:return Ee(e.type.render,!1);case 1:return Ee(e.type,!0);case 31:return we(`Activity`);default:return``}}function Oe(e){try{var t=``,n=null;do t+=De(e,n),n=e,e=e.return;while(e);return t}catch(e){return`
Error generating stack: `+e.message+`
`+e.stack}}var ke=Object.prototype.hasOwnProperty,Ae=t.unstable_scheduleCallback,je=t.unstable_cancelCallback,Me=t.unstable_shouldYield,Ne=t.unstable_requestPaint,Pe=t.unstable_now,Fe=t.unstable_getCurrentPriorityLevel,Ie=t.unstable_ImmediatePriority,Le=t.unstable_UserBlockingPriority,Re=t.unstable_NormalPriority,ze=t.unstable_LowPriority,Be=t.unstable_IdlePriority,Ve=t.log,He=t.unstable_setDisableYieldValue,Ue=null,We=null;function Ge(e){if(typeof Ve==`function`&&He(e),We&&typeof We.setStrictMode==`function`)try{We.setStrictMode(Ue,e)}catch{}}var Ke=Math.clz32?Math.clz32:Ye,qe=Math.log,Je=Math.LN2;function Ye(e){return e>>>=0,e===0?32:31-(qe(e)/Je|0)|0}var Xe=256,Ze=262144,Qe=4194304;function $e(e){var t=e&42;if(t!==0)return t;switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:return e&261888;case 262144:case 524288:case 1048576:case 2097152:return e&3932160;case 4194304:case 8388608:case 16777216:case 33554432:return e&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return e}}function et(e,t,n){var r=e.pendingLanes;if(r===0)return 0;var i=0,a=e.suspendedLanes,o=e.pingedLanes;e=e.warmLanes;var s=r&134217727;return s===0?(s=r&~a,s===0?o===0?n||(n=r&~e,n!==0&&(i=$e(n))):i=$e(o):i=$e(s)):(r=s&~a,r===0?(o&=s,o===0?n||(n=s&~e,n!==0&&(i=$e(n))):i=$e(o)):i=$e(r)),i===0?0:t!==0&&t!==i&&(t&a)===0&&(a=i&-i,n=t&-t,a>=n||a===32&&n&4194048)?t:i}function tt(e,t){return(e.pendingLanes&~(e.suspendedLanes&~e.pingedLanes)&t)===0}function nt(e,t){switch(e){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function rt(){var e=Qe;return Qe<<=1,!(Qe&62914560)&&(Qe=4194304),e}function it(e){for(var t=[],n=0;31>n;n++)t.push(e);return t}function at(e,t){e.pendingLanes|=t,t!==268435456&&(e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0)}function ot(e,t,n,r,i,a){var o=e.pendingLanes;e.pendingLanes=n,e.suspendedLanes=0,e.pingedLanes=0,e.warmLanes=0,e.expiredLanes&=n,e.entangledLanes&=n,e.errorRecoveryDisabledLanes&=n,e.shellSuspendCounter=0;var s=e.entanglements,c=e.expirationTimes,l=e.hiddenUpdates;for(n=o&~n;0<n;){var u=31-Ke(n),d=1<<u;s[u]=0,c[u]=-1;var f=l[u];if(f!==null)for(l[u]=null,u=0;u<f.length;u++){var p=f[u];p!==null&&(p.lane&=-536870913)}n&=~d}r!==0&&st(e,r,0),a!==0&&i===0&&e.tag!==0&&(e.suspendedLanes|=a&~(o&~t))}function st(e,t,n){e.pendingLanes|=t,e.suspendedLanes&=~t;var r=31-Ke(t);e.entangledLanes|=t,e.entanglements[r]=e.entanglements[r]|1073741824|n&261930}function ct(e,t){var n=e.entangledLanes|=t;for(e=e.entanglements;n;){var r=31-Ke(n),i=1<<r;i&t|e[r]&t&&(e[r]|=t),n&=~i}}function lt(e,t){var n=t&-t;return n=n&42?1:ut(n),(n&(e.suspendedLanes|t))===0?n:0}function ut(e){switch(e){case 2:e=1;break;case 8:e=4;break;case 32:e=16;break;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:e=128;break;case 268435456:e=134217728;break;default:e=0}return e}function dt(e){return e&=-e,2<e?8<e?e&134217727?32:268435456:8:2}function ft(){var e=E.p;return e===0?(e=window.event,e===void 0?32:mp(e.type)):e}function pt(e,t){var n=E.p;try{return E.p=e,t()}finally{E.p=n}}var mt=Math.random().toString(36).slice(2),ht=`__reactFiber$`+mt,gt=`__reactProps$`+mt,_t=`__reactContainer$`+mt,vt=`__reactEvents$`+mt,yt=`__reactListeners$`+mt,bt=`__reactHandles$`+mt,xt=`__reactResources$`+mt,St=`__reactMarker$`+mt;function Ct(e){delete e[ht],delete e[gt],delete e[vt],delete e[yt],delete e[bt]}function wt(e){var t=e[ht];if(t)return t;for(var n=e.parentNode;n;){if(t=n[_t]||n[ht]){if(n=t.alternate,t.child!==null||n!==null&&n.child!==null)for(e=df(e);e!==null;){if(n=e[ht])return n;e=df(e)}return t}e=n,n=e.parentNode}return null}function Tt(e){if(e=e[ht]||e[_t]){var t=e.tag;if(t===5||t===6||t===13||t===31||t===26||t===27||t===3)return e}return null}function Et(e){var t=e.tag;if(t===5||t===26||t===27||t===6)return e.stateNode;throw Error(s(33))}function Dt(e){var t=e[xt];return t||=e[xt]={hoistableStyles:new Map,hoistableScripts:new Map},t}function Ot(e){e[St]=!0}var kt=new Set,At={};function jt(e,t){Mt(e,t),Mt(e+`Capture`,t)}function Mt(e,t){for(At[e]=t,e=0;e<t.length;e++)kt.add(t[e])}var Nt=RegExp(`^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001Line truncated
`).replace(Ad,``)}function Md(e,t){return t=jd(t),jd(e)===t}function $(e,t,n,r,i,a){switch(n){case`children`:typeof r==`string`?t===`body`||t===`textarea`&&r===``||en(e,r):(typeof r==`number`||typeof r==`bigint`)&&t!==`body`&&en(e,``+r);break;case`className`:Rt(e,`class`,r);break;case`tabIndex`:Rt(e,`tabindex`,r);break;case`dir`:case`role`:case`viewBox`:case`width`:case`height`:Rt(e,n,r);break;case`style`:rn(e,r,a);break;case`data`:if(t!==`object`){Rt(e,`data`,r);break}case`src`:case`href`:if(r===``&&(t!==`a`||n!==`href`)){e.removeAttribute(n);break}if(r==null||typeof r==`function`||typeof r==`symbol`||typeof r==`boolean`){e.removeAttribute(n);break}r=cn(``+r),e.setAttribute(n,r);break;case`action`:case`formAction`:if(typeof r==`function`){e.setAttribute(n,`javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')`);break}else typeof a==`function`&&(n===`formAction`?(t!==`input`&&$(e,t,`name`,i.name,i,null),$(e,t,`formEncType`,i.formEncType,i,null),$(e,t,`formMethod`,i.formMethod,i,null),$(e,t,`formTarget`,i.formTarget,i,null)):($(e,t,`encType`,i.encType,i,null),$(e,t,`method`,i.method,i,null),$(e,t,`target`,i.target,i,null)));if(r==null||typeof r==`symbol`||typeof r==`boolean`){e.removeAttribute(n);break}r=cn(``+r),e.setAttribute(n,r);break;case`onClick`:r!=null&&(e.onclick=ln);break;case`onScroll`:r!=null&&Q(`scroll`,e);break;case`onScrollEnd`:r!=null&&Q(`scrollend`,e);break;case`dangerouslySetInnerHTML`:if(r!=null){if(typeof r!=`object`||!(`__html`in r))throw Error(s(61));if(n=r.__html,n!=null){if(i.children!=null)throw Error(s(60));e.innerHTML=n}}break;case`multiple`:e.multiple=r&&typeof r!=`function`&&typeof r!=`symbol`;break;case`muted`:e.muted=r&&typeof r!=`function`&&typeof r!=`symbol`;break;case`suppressContentEditableWarning`:case`suppressHydrationWarning`:case`defaultValue`:case`defaultChecked`:case`innerHTML`:case`ref`:break;case`autoFocus`:break;case`xlinkHref`:if(r==null||typeof r==`function`||typeof r==`boolean`||typeof r==`symbol`){e.removeAttribute(`xlink:href`);break}n=cn(``+r),e.setAttributeNS(`http://www.w3.org/1999/xlink`,`xlink:href`,n);break;case`contentEditable`:case`spellCheck`:case`draggable`:case`value`:case`autoReverse`:case`externalResourcesRequired`:case`focusable`:case`preserveAlpha`:r!=null&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,``+r):e.removeAttribute(n);break;case`inert`:case`allowFullScreen`:case`async`:case`autoPlay`:case`controls`:case`default`:case`defer`:case`disabled`:case`disablePictureInPicture`:case`disableRemotePlayback`:case`formNoValidate`:case`hidden`:case`loop`:case`noModule`:case`noValidate`:case`open`:case`playsInline`:case`readOnly`:case`required`:case`reversed`:case`scoped`:case`seamless`:case`itemScope`:r&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,``):e.removeAttribute(n);break;case`capture`:case`download`:!0===r?e.setAttribute(n,``):!1!==r&&r!=null&&typeof r!=`function`&&typeof r!=`symbol`?e.setAttribute(n,r):e.removeAttribute(n);break;case`cols`:case`rows`:case`size`:case`span`:r!=null&&typeof r!=`function`&&typeof r!=`symbol`&&!isNaN(r)&&1<=r?e.setAttribute(n,r):e.removeAttribute(n);break;case`rowSpan`:case`start`:r==null||typeof r==`function`||typeof r==`symbol`||isNaN(r)?e.removeAttribute(n):e.setAttribute(n,r);break;case`popover`:Q(`beforetoggle`,e),Q(`toggle`,e),Lt(e,`popover`,r);break;case`xlinkActuate`:zt(e,`http://www.w3.org/1999/xlink`,`xlink:actuate`,r);break;case`xlinkArcrole`:zt(e,`http://www.w3.org/1999/xlink`,`xlink:arcrole`,r);break;case`xlinkRole`:zt(e,`http://www.w3.org/1999/xlink`,`xlink:role`,r);break;case`xlinkShow`:zt(e,`http://www.w3.org/1999/xlink`,`xlink:show`,r);break;case`xlinkTitle`:zt(e,`http://www.w3.org/1999/xlink`,`xlink:title`,r);break;case`xlinkType`:zt(e,`http://www.w3.org/1999/xlink`,`xlink:type`,r);break;case`xmlBase`:zt(e,`http://www.w3.org/XML/1998/namespace`,`xml:base`,r);break;case`xmlLang`:zt(e,`http://www.w3.org/XML/1998/namespace`,`xml:lang`,r);break;case`xmlSpace`:zt(e,`http://www.w3.org/XML/1998/namespace`,`xml:space`,r);break;case`is`:Lt(e,`is`,r);break;case`innerText`:case`textContent`:break;default:(!(2<n.length)||n[0]!==`o`&&n[0]!==`O`||n[1]!==`n`&&n[1]!==`N`)&&(n=on.get(n)||n,Lt(e,n,r))}}function Nd(e,t,n,r,i,a){switch(n){case`style`:rn(e,r,a);break;case`dangerouslySetInnerHTML`:if(r!=null){if(typeof r!=`object`||!(`__html`in r))throw Error(s(61));if(n=r.__html,n!=null){if(i.children!=null)throw Error(s(60));e.innerHTML=n}}break;case`children`:typeof r==`string`?en(e,r):(typeof r==`number`||typeof r==`bigint`)&&en(e,``+r);break;case`onScroll`:r!=null&&Q(`scroll`,e);break;case`onScrollEnd`:r!=null&&Q(`scrollend`,e);break;case`onClick`:r!=null&&(e.onclick=ln);break;case`suppressContentEditableWarning`:case`suppressHydrationWarning`:case`innerHTML`:case`re Line truncated
+1 -1
View File
@@ -5,7 +5,7 @@
<link rel="icon" type="image/svg+xml" href="/assets/icon-small-BO4dlTNl.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>GPGUI Downloader</title>
<script type="module" crossorigin src="/assets/main-B7u6_mhO.js"></script>
<script type="module" crossorigin src="/assets/main-BD0fDtWU.js"></script>
<link rel="stylesheet" crossorigin href="/assets/main-DiWGniCh.css">
</head>
<body>
+13 -13
View File
@@ -9,25 +9,25 @@
"tauri": "tauri"
},
"dependencies": {
"@tauri-apps/api": "^2.12.1",
"react": "^19.3.0",
"react-dom": "^19.3.0"
"@tauri-apps/api": "^2.11.1",
"react": "^19.2.7",
"react-dom": "^19.2.7"
},
"devDependencies": {
"@tauri-apps/cli": "^2.12.1",
"@types/node": "^26.6.4",
"@types/react": "^19.3.0",
"@types/react-dom": "^19.3.0",
"@typescript-eslint/eslint-plugin": "^8.71.1",
"@typescript-eslint/parser": "^8.71.1",
"@vitejs/plugin-react": "^6.1.2",
"eslint": "^9.39.5",
"@tauri-apps/cli": "^2.11.2",
"@types/node": "^25.9.4",
"@types/react": "^19.2.17",
"@types/react-dom": "^19.2.3",
"@typescript-eslint/eslint-plugin": "^8.61.1",
"@typescript-eslint/parser": "^8.61.1",
"@vitejs/plugin-react": "^6.0.2",
"eslint": "^9.39.4",
"eslint-config-prettier": "^10.1.8",
"eslint-plugin-react": "^7.37.5",
"eslint-plugin-react-hooks": "^7.1.1",
"prettier": "3.9.9",
"prettier": "3.8.3",
"typescript": "^6.0.3",
"vite": "^8.3.3"
"vite": "^8.0.16"
},
"packageManager": "[email protected]"
}
+538 -488
View File
File diff suppressed because it is too large. Load diff
+4 -2
View File
@@ -246,7 +246,9 @@ async fn run_installer_connection(
rejection.code(),
rejection.message()
)),
_ => Err(anyhow::anyhow!("Service sent an unexpected GUI installation reply")),
ServiceResult::VpncScriptMetadata(_) => {
Err(anyhow::anyhow!("Service sent an unexpected VPNC script metadata reply"))
}
};
let _ = command.reply.send(result);
}
@@ -299,7 +301,6 @@ async fn connect_installer_at(
let (mut socket, _) = connect_async_with_config(endpoint, Some(config), false).await?;
let prelude = ClientPrelude {
product_version: credential.product_version().to_owned(),
hip_protocol_version: gpapi::service::transport::HIP_PROTOCOL_VERSION,
service_instance_id: credential.service_instance_id(),
session_id: credential.session_id(),
};
@@ -632,6 +633,7 @@ mod tests {
snapshot: VpnEnv {
vpn_state: VpnState::Disconnected,
vpnc_script: None,
csd_wrapper: None,
auth_executable: String::new(),
host_info: HostInfo {
host_identity: HostIdentity::collect(),
+1 -1
View File
@@ -22,7 +22,7 @@ export default defineConfig(async () => {
build: {
rolldownOptions: {
input: {
main: resolve(import.meta.dirname, "index.html"),
main: resolve(__dirname, "index.html"),
},
},
},
+1 -6
View File
@@ -7,9 +7,6 @@ license.workspace = true
[dependencies]
common = { path = "../../crates/common" }
gpapi = { path = "../../crates/gpapi", features = ["clap", "logger"] }
gphip = { path = "../../crates/gphip" }
base64.workspace = true
sha256.workspace = true
openconnect = { path = "../../crates/openconnect" }
clap.workspace = true
anyhow.workspace = true
@@ -28,12 +25,10 @@ thiserror.workspace = true
uuid = { workspace = true, features = ["v4"] }
zeroize.workspace = true
tempfile.workspace = true
getrandom = "0.4"
mac_address = "1"
[target.'cfg(unix)'.dependencies]
nix = { version = "0.31", features = ["fs", "socket", "user"] }
[dev-dependencies]
openssl.workspace = true
tokio-tungstenite = "0.29"
sha256.workspace = true
@@ -1,10 +0,0 @@
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[path = "privileged_unix.rs"]
mod platform;
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
#[path = "unsupported.rs"]
mod platform;
fn main() {
platform::run();
}
@@ -1,56 +0,0 @@
use std::io::Read;
use anyhow::{Context, ensure};
use clap::{Parser, Subcommand};
use gpservice::hip_approval::{self, InstallRequest};
use nix::unistd::Uid;
const MAX_INSTALL_REQUEST_SIZE: u64 = 2 * 1024 * 1024;
#[derive(Parser)]
struct Cli {
#[command(subcommand)]
command: Command,
}
#[derive(Subcommand)]
enum Command {
Install,
Revoke { approval_id: String },
}
fn try_run() -> anyhow::Result<()> {
ensure!(Uid::effective().is_root(), "HIP script installer must run as root");
let approving_uid = std::env::var("PKEXEC_UID")
.context("HIP script installer requires pkexec authorization")?
.parse::<u32>()
.context("Invalid pkexec user identity")?;
ensure!(approving_uid != 0, "HIP script installer requires a desktop user");
match Cli::parse().command {
Command::Install => {
let mut input = Vec::new();
std::io::stdin()
.lock()
.take(MAX_INSTALL_REQUEST_SIZE + 1)
.read_to_end(&mut input)?;
ensure!(
input.len() as u64 <= MAX_INSTALL_REQUEST_SIZE,
"HIP install request is too large"
);
let request: InstallRequest = serde_json::from_slice(&input).context("Invalid HIP install request")?;
let info = hip_approval::install(request, approving_uid)?;
serde_json::to_writer(std::io::stdout().lock(), &info)?;
println!();
}
Command::Revoke { approval_id } => hip_approval::revoke(&approval_id, approving_uid)?,
}
Ok(())
}
pub(super) fn run() {
if let Err(err) = try_run() {
eprintln!("HIP approval failed: {err:#}");
std::process::exit(1);
}
}
@@ -1,4 +0,0 @@
pub(super) fn run() {
eprintln!("Root HIP script approvals are unavailable on this platform");
std::process::exit(1);
}
+77 -58
View File
@@ -1,8 +1,11 @@
use std::io::Write;
use std::path::PathBuf;
use std::sync::{Arc, atomic::AtomicBool};
use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
#[cfg(target_os = "macos")]
use std::time::Duration;
use std::{collections::HashMap, io::Write};
use anyhow::{Context, bail};
use clap::Parser;
@@ -12,8 +15,9 @@ use gpapi::logger;
#[cfg(debug_assertions)]
use gpapi::utils::lock_file::dev_service_lock_file_path;
use gpapi::{
service::vpn_state::VpnState,
utils::{lock_file::LockFile, redact::Redaction, shutdown_signal},
process::gui_launcher::GuiLauncher,
service::{request::WsRequest, vpn_state::VpnState},
utils::{env_utils, lock_file::LockFile, redact::Redaction, shutdown_signal},
};
#[cfg(target_os = "macos")]
use log::{Log, Metadata, Record};
@@ -60,9 +64,9 @@ impl Log for RedactingMacosLogger {
#[command(version = VERSION)]
struct Cli {
#[clap(long)]
#[cfg_attr(debug_assertions, clap(conflicts_with = "dev_standalone"))]
#[cfg_attr(target_os = "macos", clap(conflicts_with = "macos_brokered"))]
desktop_credentials: bool,
minimized: bool,
#[clap(long)]
env_file: Option<String>,
#[cfg(debug_assertions)]
#[clap(long, requires_all = ["dev_uid", "dev_bootstrap_socket"])]
dev_standalone: bool,
@@ -91,34 +95,14 @@ impl Cli {
bail!("Another instance of the service is already running");
}
// Channel for receiving VPN state from the lifecycle actor
// Channel for sending requests to the VPN task
let (ws_req_tx, ws_req_rx) = mpsc::channel::<WsRequest>(32);
// Channel for receiving the VPN state from the VPN task
let (vpn_state_tx, vpn_state_rx) = watch::channel(VpnState::Disconnected);
let gui_restart_requested = Arc::new(AtomicBool::new(false));
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let externally_brokered = self.externally_brokered();
let desktop_uid = if self.desktop_credentials {
anyhow::ensure!(
nix::unistd::Uid::effective().is_root(),
"Desktop credentials require a privileged service"
);
let uid: u32 = std::env::var("PKEXEC_UID")
.context("Desktop credentials require a pkexec-authenticated user")?
.parse()
.context("Invalid pkexec user")?;
anyhow::ensure!(uid != 0, "Desktop credentials require a non-root user");
anyhow::ensure!(
nix::unistd::User::from_uid(nix::unistd::Uid::from_raw(uid))?.is_some(),
"Desktop user is unavailable"
);
Some(uid)
} else {
crate::runtime_user::desktop_uid()
};
let desktop_channel = if self.desktop_credentials {
Some(crate::desktop_client::DesktopClient::from_stdio()?)
} else {
None
};
let trusted_csd_uid = crate::runtime_user::trusted_csd_uid()?;
let brokered_scripts_dir = if externally_brokered {
let executable = std::env::current_exe().context("Failed to locate the gpservice executable")?;
let contents_dir = executable
@@ -129,14 +113,15 @@ impl Cli {
} else {
None
};
let (mut vpn_task, lifecycle) = VpnTask::new(vpn_state_tx, externally_brokered, Arc::clone(&registry));
let dispatcher = Arc::new(RequestDispatcher::new(
lifecycle.clone(),
ws_req_tx.clone(),
Arc::clone(&gui_restart_requested),
Arc::clone(&redaction),
!externally_brokered,
brokered_scripts_dir,
));
let mut vpn_task = VpnTask::new(ws_req_rx, vpn_state_tx, externally_brokered, trusted_csd_uid);
#[cfg(target_os = "macos")]
let idle_vpn_state_rx = vpn_state_rx.clone();
let ws_server = WsServer::new(
@@ -194,34 +179,32 @@ impl Cli {
#[cfg(unix)]
{
let lifecycle = lifecycle.clone();
let vpn_ctx = vpn_task.context();
let ws_ctx = ws_server.context();
tokio::spawn(async move { signals::handle_signals(lifecycle, ws_ctx).await });
tokio::spawn(async move { signals::handle_signals(vpn_ctx, ws_ctx).await });
}
let desktop_cancel = server_token.clone();
let shutdown_token = server_token.clone();
let vpn_task_handle = tokio::spawn(async move { vpn_task.start(server_token).await });
let (ws_ready_tx, ws_ready_rx) = tokio::sync::oneshot::channel();
let ws_server_handle = tokio::spawn(async move { ws_server.start(shutdown_tx_clone, ws_ready_tx).await });
let desktop_client_handle = if let Some(channel) = desktop_channel {
#[cfg(debug_assertions)]
let launch_managed_gui = !self.dev_standalone && !externally_brokered;
#[cfg(not(debug_assertions))]
let launch_managed_gui = !externally_brokered;
if launch_managed_gui {
ws_ready_rx.await.context("WebSocket server failed to start")?;
let desktop_uid = desktop_uid.context("Desktop user is unavailable")?;
Some(tokio::spawn(async move {
if let Err(err) = channel
.serve(registry, desktop_uid, gui_restart_requested, desktop_cancel)
.await
{
warn!("Desktop credential channel ended: {err}");
}
let envs = self.env_file.as_ref().map(env_utils::load_env_vars).transpose()?;
let minimized = self.minimized;
tokio::spawn(async move {
launch_gui(envs, registry, minimized, gui_restart_requested).await;
let _ = shutdown_tx.send(()).await;
}))
});
} else {
info!("Running with an externally launched GUI");
None
};
info!("Running with a separately started debug GUI");
}
tokio::select! {
_ = shutdown_signal() => {
@@ -233,11 +216,7 @@ impl Cli {
}
vpn_task_cancel_token.cancel();
shutdown_token.cancel();
let _ = tokio::join!(vpn_task_handle, ws_server_handle);
if let Some(handle) = desktop_client_handle {
let _ = handle.await;
}
lock_file.unlock()?;
@@ -325,7 +304,7 @@ async fn wait_for_brokered_idle(
_ = interval.tick() => {},
}
let idle = matches!(*vpn_state_rx.borrow(), VpnState::Disconnected | VpnState::Failed(_)) && registry.is_empty();
let idle = matches!(*vpn_state_rx.borrow(), VpnState::Disconnected) && registry.is_empty();
if !idle {
idle_since = None;
continue;
@@ -345,12 +324,12 @@ mod signals {
use log::{info, warn};
use crate::vpn_task::LifecycleHandle;
use crate::vpn_task::VpnTaskContext;
use crate::ws_server::WsServerContext;
const DISCONNECTED_PID_FILE: &str = "/tmp/gpservice_disconnected.pid";
pub async fn handle_signals(lifecycle: LifecycleHandle, ws_ctx: Arc<WsServerContext>) {
pub async fn handle_signals(vpn_ctx: Arc<VpnTaskContext>, ws_ctx: Arc<WsServerContext>) {
use gpapi::service::event::WsEvent;
use tokio::signal::unix::{Signal, SignalKind, signal};
@@ -370,7 +349,7 @@ mod signals {
tokio::select! {
_ = user_sig1.recv() => {
info!("Received SIGUSR1 signal");
if lifecycle.disconnect_and_wait().await {
if vpn_ctx.disconnect().await {
// Write the PID to a dedicated file to indicate that the VPN task is disconnected via SIGUSR1
let pid = std::process::id();
if let Err(err) = tokio::fs::write(DISCONNECTED_PID_FILE, pid.to_string()).await {
@@ -387,6 +366,46 @@ mod signals {
}
}
async fn launch_gui(
envs: Option<HashMap<String, String>>,
registry: Arc<SessionRegistry>,
mut minimized: bool,
restart_requested: Arc<AtomicBool>,
) {
loop {
let credential = match registry.issue(env!("CARGO_PKG_VERSION")) {
Ok(credential) => credential,
Err(err) => {
warn!("Failed to issue GUI credential: {err}");
break;
}
};
let session_id = credential.session_id();
let gui_launcher = GuiLauncher::new(env!("CARGO_PKG_VERSION"), credential)
.envs(envs.clone())
.minimized(minimized);
match gui_launcher.launch().await {
Ok(exit_status) => {
registry.revoke(session_id);
let should_restart = restart_requested.swap(false, Ordering::SeqCst);
if !should_restart {
info!("GUI exited with code {:?}", exit_status.code());
break;
}
info!("GUI restart requested, restarting");
minimized = false;
}
Err(err) => {
registry.revoke(session_id);
warn!("Failed to launch GUI: {}", err);
break;
}
}
}
}
pub async fn run() {
let mut cli = Cli::parse();
+2 -6
View File
@@ -7,12 +7,8 @@ use tokio::{
use crate::session_registry::SessionRegistry;
pub(crate) async fn serve(
mut stream: UnixStream,
registry: Arc<SessionRegistry>,
desktop_uid: Option<u32>,
) -> anyhow::Result<()> {
let credential = registry.issue(env!("CARGO_PKG_VERSION"), desktop_uid)?;
pub(crate) async fn serve(mut stream: UnixStream, registry: Arc<SessionRegistry>) -> anyhow::Result<()> {
let credential = registry.issue(env!("CARGO_PKG_VERSION"))?;
let session_id = credential.session_id();
let result = async {
stream.write_all(&credential.encode_frame()?).await?;
-223
View File
@@ -1,223 +0,0 @@
use std::{
io,
os::fd::OwnedFd,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
};
use anyhow::{Context, ensure};
use nix::{
fcntl::{FcntlArg, FdFlag, OFlag, fcntl},
sys::stat::{SFlag, fstat},
unistd::{dup, read, write},
};
use tokio::io::unix::AsyncFd;
use tokio_util::sync::CancellationToken;
use crate::session_registry::SessionRegistry;
/// Private parent/service pipes; credentials never pass through argv, environment or files.
pub(crate) struct DesktopClient {
input: AsyncFd<OwnedFd>,
output: AsyncFd<OwnedFd>,
}
impl DesktopClient {
pub(crate) fn from_stdio() -> anyhow::Result<Self> {
let channel = Self::new(dup(std::io::stdin())?, dup(std::io::stdout())?)?;
// Only the owned CLOEXEC descriptors carry credentials. VPN subprocesses inherit /dev/null.
let null = std::fs::OpenOptions::new().read(true).write(true).open("/dev/null")?;
nix::unistd::dup2_stdin(&null)?;
nix::unistd::dup2_stdout(&null)?;
Ok(channel)
}
fn new(input: OwnedFd, output: OwnedFd) -> anyhow::Result<Self> {
fn pipe(fd: OwnedFd) -> anyhow::Result<AsyncFd<OwnedFd>> {
ensure!(
SFlag::from_bits_truncate(fstat(&fd)?.st_mode).contains(SFlag::S_IFIFO),
"Desktop credentials require private pipes"
);
fcntl(&fd, FcntlArg::F_SETFD(FdFlag::FD_CLOEXEC))?;
let flags = OFlag::from_bits_truncate(fcntl(&fd, FcntlArg::F_GETFL)?);
fcntl(&fd, FcntlArg::F_SETFL(flags | OFlag::O_NONBLOCK))?;
Ok(AsyncFd::new(fd)?)
}
Ok(Self {
input: pipe(input)?,
output: pipe(output)?,
})
}
pub(crate) async fn serve(
self,
registry: Arc<SessionRegistry>,
uid: u32,
restart: Arc<AtomicBool>,
cancel: CancellationToken,
) -> anyhow::Result<()> {
loop {
let credential = registry.issue(env!("CARGO_PKG_VERSION"), Some(uid))?;
let session_id = credential.session_id();
let result = tokio::select! {
_ = cancel.cancelled() => Ok(false),
result = async {
self.write_frame(&credential.encode_frame()?).await?;
self.gui_exited().await
} => result,
};
registry.revoke(session_id);
if !result? || !restart.swap(false, Ordering::SeqCst) {
return Ok(());
}
}
}
async fn write_frame(&self, mut bytes: &[u8]) -> anyhow::Result<()> {
while !bytes.is_empty() {
let mut ready = self.output.writable().await?;
match ready.try_io(|fd| write(fd.get_ref(), bytes).map_err(io::Error::from)) {
Ok(result) => {
let length = result?;
ensure!(length != 0, "Desktop credential pipe closed");
bytes = &bytes[length..];
}
Err(_) => continue,
}
}
Ok(())
}
async fn gui_exited(&self) -> anyhow::Result<bool> {
loop {
let mut ready = self.input.readable().await?;
let mut byte = [0];
match ready.try_io(|fd| read(fd.get_ref(), &mut byte).map_err(io::Error::from)) {
Ok(result) => {
if result.context("Desktop control pipe failed")? == 0 {
return Ok(false);
}
ensure!(byte[0] == 0, "Invalid desktop control message");
return Ok(true);
}
Err(_) => continue,
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn credential_stdio_is_not_inherited_by_subprocesses() {
let output = std::process::Command::new(std::env::current_exe().unwrap())
.args(["--ignored", "--exact", "desktop_client::tests::stdio_child"])
.stdin(std::process::Stdio::piped())
.output()
.unwrap();
assert!(output.status.success());
let text = String::from_utf8_lossy(&output.stdout);
assert!(text.contains("PRIVATE_FRAME"));
assert!(!text.contains("CHILD_OUTPUT"));
}
#[tokio::test]
#[ignore = "subprocess fixture for credential_stdio_is_not_inherited_by_subprocesses"]
async fn stdio_child() {
let channel = DesktopClient::from_stdio().unwrap();
assert!(
std::process::Command::new("/bin/sh")
.args(["-c", "printf CHILD_OUTPUT"])
.status()
.unwrap()
.success()
);
channel.write_frame(b"PRIVATE_FRAME").await.unwrap();
}
use gpapi::service::transport::SessionCredential;
use nix::unistd::pipe;
use std::{fs::File, io::Read, time::Duration};
fn pipes() -> (DesktopClient, OwnedFd, File) {
let (input, control) = pipe().unwrap();
let (credentials, output) = pipe().unwrap();
(DesktopClient::new(input, output).unwrap(), control, credentials.into())
}
async fn credential(mut reader: File) -> (File, SessionCredential) {
tokio::task::spawn_blocking(move || {
let mut header = [0; 2];
reader.read_exact(&mut header).unwrap();
let mut frame = zeroize::Zeroizing::new(vec![0; usize::from(u16::from_be_bytes(header)) + 2]);
frame[..2].copy_from_slice(&header);
reader.read_exact(&mut frame[2..]).unwrap();
let credential = SessionCredential::decode_frame(&frame).unwrap();
(reader, credential)
})
.await
.unwrap()
}
#[tokio::test]
async fn desktop_channel_revokes_and_reissues_on_restart_then_closes_on_parent_exit() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let restart = Arc::new(AtomicBool::new(false));
let task = tokio::spawn(channel.serve(registry.clone(), 1000, restart.clone(), CancellationToken::new()));
let (reader, first) = credential(reader).await;
restart.store(true, Ordering::SeqCst);
write(&control, &[0]).unwrap();
let (_, second) = credential(reader).await;
assert_ne!(first.session_id(), second.session_id());
assert!(registry.last_successful_hip_report(first.session_id()).is_err());
drop(control);
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.unwrap();
assert!(registry.last_successful_hip_report(second.session_id()).is_err());
}
#[tokio::test]
async fn desktop_channel_shutdown_cancels_pipe_wait_and_revokes_credential() {
let (channel, _control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let cancel = CancellationToken::new();
let task = tokio::spawn(channel.serve(registry.clone(), 1000, Arc::new(AtomicBool::new(false)), cancel.clone()));
let (_, issued) = credential(reader).await;
cancel.cancel();
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.unwrap();
assert!(registry.last_successful_hip_report(issued.session_id()).is_err());
}
#[tokio::test]
async fn desktop_channel_rejects_invalid_control_messages_and_revokes() {
let (channel, control, reader) = pipes();
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
let task = tokio::spawn(channel.serve(
registry.clone(),
1000,
Arc::new(AtomicBool::new(false)),
CancellationToken::new(),
));
let (_, issued) = credential(reader).await;
write(&control, &[1]).unwrap();
assert!(
tokio::time::timeout(Duration::from_secs(1), task)
.await
.unwrap()
.unwrap()
.is_err()
);
assert!(registry.last_successful_hip_report(issued.session_id()).is_err());
}
}
+2 -2
View File
@@ -54,7 +54,7 @@ impl DevBootstrap {
}
let registry = Arc::clone(&self.registry);
tokio::spawn(async move {
if let Err(err) = credential_lease::serve(stream, registry, Some(self.allowed_uid)).await {
if let Err(err) = credential_lease::serve(stream, registry).await {
warn!("Debug credential client ended: {err}");
}
});
@@ -188,7 +188,7 @@ mod tests {
async fn anchor_eof_revokes_issued_credential() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let (service, mut client) = UnixStream::pair().unwrap();
let task = tokio::spawn(credential_lease::serve(service, Arc::clone(&registry), Some(1234)));
let task = tokio::spawn(credential_lease::serve(service, Arc::clone(&registry)));
let mut header = [0_u8; 2];
client.read_exact(&mut header).await.unwrap();
-380
View File
@@ -1,380 +0,0 @@
//! Root-owned Unix installation identity. Failure affects GUI issuance only.
use anyhow::{Context, ensure};
use gpapi::device_anchor::{AnchorSource, DeviceAnchor};
use serde::{Deserialize, Serialize};
use std::{
fs::{self, File, OpenOptions},
io::{Read, Write},
os::unix::fs::{DirBuilderExt, MetadataExt, OpenOptionsExt, PermissionsExt},
path::Path,
};
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct Record {
version: u32,
anchor: DeviceAnchor,
}
pub fn resolve() -> anyhow::Result<DeviceAnchor> {
resolve_in(Path::new("/var/lib/gp"), 0, collect_unix).context("cannot resolve persistent GUI device anchor")
}
fn collect_unix() -> anyhow::Result<DeviceAnchor> {
collect_from(mac_address::get_mac_address()?, || {
let mut random = [0_u8; 32];
getrandom::fill(&mut random).map_err(|_| anyhow::anyhow!("cannot initialize device anchor"))?;
Ok(random)
})
}
fn collect_from(
mac: Option<mac_address::MacAddress>,
random: impl FnOnce() -> anyhow::Result<[u8; 32]>,
) -> anyhow::Result<DeviceAnchor> {
if let Some(mac) = mac {
let bytes = mac.bytes();
if bytes != [0; 6] && bytes[0] & 1 == 0 {
return Ok(DeviceAnchor::derive(AnchorSource::UnixMac, bytes));
}
}
Ok(DeviceAnchor::derive(AnchorSource::UnixRandom, random()?))
}
fn validate_metadata(metadata: &fs::Metadata, owner: u32, directory: bool) -> anyhow::Result<()> {
ensure!(
if directory {
metadata.is_dir()
} else {
metadata.is_file()
},
"unexpected device anchor state type"
);
ensure!(metadata.uid() == owner, "unexpected device anchor state owner");
ensure!(
metadata.permissions().mode() & 0o777 == if directory { 0o700 } else { 0o600 },
"unsafe device anchor state permissions"
);
if !directory {
ensure!(metadata.nlink() == 1, "device anchor state must not have hard links");
}
Ok(())
}
fn read_record(path: &Path, owner: u32) -> anyhow::Result<Option<DeviceAnchor>> {
let mut file = match OpenOptions::new()
.read(true)
.custom_flags(nix::libc::O_NOFOLLOW | nix::libc::O_NONBLOCK)
.open(path)
{
Ok(file) => file,
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None),
Err(error) => return Err(error.into()),
};
validate_metadata(&file.metadata()?, owner, false)?;
ensure!(file.metadata()?.len() <= 4096, "oversized device anchor record");
let mut bytes = Vec::new();
file.read_to_end(&mut bytes)?;
let record: Record = serde_json::from_slice(&bytes).context("malformed device anchor record")?;
ensure!(
record.version == 1 && record.anchor.validate(),
"unsupported or invalid device anchor record"
);
ensure!(
matches!(record.anchor.source, AnchorSource::UnixMac | AnchorSource::UnixRandom),
"invalid Unix device anchor source"
);
Ok(Some(record.anchor))
}
fn resolve_in(
directory: &Path,
owner: u32,
collect: impl FnOnce() -> anyhow::Result<DeviceAnchor>,
) -> anyhow::Result<DeviceAnchor> {
match fs::DirBuilder::new().mode(0o700).create(directory) {
Ok(()) => {
if let Some(parent) = directory.parent() {
File::open(parent)?.sync_all()?;
}
}
Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {}
Err(error) => return Err(error.into()),
}
validate_metadata(&fs::symlink_metadata(directory)?, owner, true)?;
let path = directory.join("hardware-id");
let lock = OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.mode(0o600)
.custom_flags(nix::libc::O_NOFOLLOW | nix::libc::O_NONBLOCK)
.open(directory.join("hardware-id.lock"))?;
validate_metadata(&lock.metadata()?, owner, false)?;
lock.lock()?;
if let Some(anchor) = read_record(&path, owner)? {
return Ok(anchor);
}
let anchor = collect()?;
ensure!(
anchor.validate() && matches!(anchor.source, AnchorSource::UnixMac | AnchorSource::UnixRandom),
"invalid collected Unix device anchor"
);
let mut temporary = tempfile::NamedTempFile::new_in(directory)?;
temporary.as_file().set_permissions(fs::Permissions::from_mode(0o600))?;
temporary.write_all(&serde_json::to_vec(&Record {
version: 1,
anchor: anchor.clone(),
})?)?;
temporary.as_file().sync_all()?;
temporary.persist_noclobber(&path)?;
File::open(directory)?.sync_all()?;
Ok(anchor)
}
#[cfg(test)]
mod tests {
use super::*;
fn anchor() -> anyhow::Result<DeviceAnchor> {
Ok(DeviceAnchor {
hardware_id: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".to_owned(),
source: AnchorSource::UnixMac,
})
}
#[test]
fn persistence_reuses_the_existing_record_without_rediscovery() {
let _ = resolve as fn() -> anyhow::Result<DeviceAnchor>;
let temporary = tempfile::tempdir().unwrap();
let path = temporary.path().join("state");
let owner = nix::unistd::Uid::current().as_raw();
assert_eq!(resolve_in(&path, owner, anchor).unwrap(), anchor().unwrap());
assert_eq!(
resolve_in(&path, owner, || anyhow::bail!("must not rediscover")).unwrap(),
anchor().unwrap()
);
}
#[test]
fn collector_preserves_an_eligible_mac_and_randomizes_ineligible_addresses() {
use mac_address::MacAddress;
let eligible = collect_from(Some(MacAddress::new([0, 17, 34, 51, 68, 85])), || {
anyhow::bail!("must not randomize")
})
.unwrap();
assert_eq!(
eligible,
DeviceAnchor::derive(AnchorSource::UnixMac, [0, 17, 34, 51, 68, 85])
);
for rejected in [[0; 6], [1, 2, 3, 4, 5, 6], [0xff; 6]] {
assert_eq!(
collect_from(Some(MacAddress::new(rejected)), || Ok([9; 32])).unwrap(),
DeviceAnchor::derive(AnchorSource::UnixRandom, [9; 32])
);
}
assert_eq!(
collect_from(None, || Ok([8; 32])).unwrap(),
DeviceAnchor::derive(AnchorSource::UnixRandom, [8; 32])
);
}
#[test]
fn deleting_the_record_recreates_the_same_mac_anchor() {
let temporary = tempfile::tempdir().unwrap();
let path = temporary.path().join("state");
let owner = nix::unistd::Uid::current().as_raw();
let first = resolve_in(&path, owner, anchor).unwrap();
fs::remove_file(path.join("hardware-id")).unwrap();
assert_eq!(resolve_in(&path, owner, anchor).unwrap(), first);
}
#[test]
fn parallel_first_start_converges_on_one_record() {
use std::sync::{Arc, Barrier};
let temporary = tempfile::tempdir().unwrap();
let path = Arc::new(temporary.path().join("state"));
fs::create_dir(&*path).unwrap();
fs::set_permissions(&*path, fs::Permissions::from_mode(0o700)).unwrap();
let owner = nix::unistd::Uid::current().as_raw();
let barrier = Arc::new(Barrier::new(2));
let handles: Vec<_> = [AnchorSource::UnixMac, AnchorSource::UnixRandom]
.into_iter()
.map(|source| {
let path = Arc::clone(&path);
let barrier = Arc::clone(&barrier);
std::thread::spawn(move || {
barrier.wait();
resolve_in(&path, owner, || Ok(DeviceAnchor::derive(source, [source.into()])))
})
})
.collect();
let results: Vec<_> = handles
.into_iter()
.map(|handle| handle.join().unwrap().unwrap())
.collect();
assert_eq!(results[0], results[1]);
assert_eq!(
read_record(&path.join("hardware-id"), owner).unwrap(),
Some(results[0].clone())
);
}
#[test]
fn rejects_malformed_linked_and_unsafe_records() {
use std::os::unix::fs::symlink;
let owner = nix::unistd::Uid::current().as_raw();
for case in ["malformed", "symlink", "hard-link", "permissions"] {
let temporary = tempfile::tempdir().unwrap();
let directory = temporary.path().join("state");
fs::create_dir(&directory).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap();
let record = directory.join("hardware-id");
match case {
"malformed" => fs::write(&record, b"not-json").unwrap(),
"symlink" => {
let target = temporary.path().join("target");
fs::write(
&target,
serde_json::to_vec(&Record {
version: 1,
anchor: anchor().unwrap(),
})
.unwrap(),
)
.unwrap();
symlink(target, &record).unwrap();
}
"hard-link" => {
fs::write(
&record,
serde_json::to_vec(&Record {
version: 1,
anchor: anchor().unwrap(),
})
.unwrap(),
)
.unwrap();
fs::hard_link(&record, temporary.path().join("second-link")).unwrap();
}
"permissions" => {
fs::write(
&record,
serde_json::to_vec(&Record {
version: 1,
anchor: anchor().unwrap(),
})
.unwrap(),
)
.unwrap();
fs::set_permissions(&record, fs::Permissions::from_mode(0o644)).unwrap();
}
_ => unreachable!(),
}
if case != "symlink" && case != "permissions" {
fs::set_permissions(&record, fs::Permissions::from_mode(0o600)).unwrap();
}
assert!(resolve_in(&directory, owner, anchor).is_err(), "accepted {case}");
}
}
#[test]
fn recovers_with_an_interrupted_temporary_file_present() {
let temporary = tempfile::tempdir().unwrap();
let directory = temporary.path().join("state");
fs::create_dir(&directory).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap();
fs::write(directory.join(".hardware-id.interrupted"), b"partial").unwrap();
assert_eq!(
resolve_in(&directory, nix::unistd::Uid::current().as_raw(), anchor).unwrap(),
anchor().unwrap()
);
}
#[test]
fn rejects_unsafe_directory_and_lock_metadata_and_read_only_storage() {
use std::os::unix::fs::symlink;
let owner = nix::unistd::Uid::current().as_raw();
let temporary = tempfile::tempdir().unwrap();
let directory = temporary.path().join("state");
fs::create_dir(&directory).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o755)).unwrap();
assert!(resolve_in(&directory, owner, anchor).is_err());
let temporary = tempfile::tempdir().unwrap();
let directory = temporary.path().join("state");
fs::create_dir(&directory).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap();
assert!(resolve_in(&directory, owner.wrapping_add(1), anchor).is_err());
let temporary = tempfile::tempdir().unwrap();
let directory = temporary.path().join("state");
fs::write(&directory, b"not-a-directory").unwrap();
assert!(resolve_in(&directory, owner, anchor).is_err());
for case in ["symlink", "hard-link", "permissions"] {
let temporary = tempfile::tempdir().unwrap();
let directory = temporary.path().join("state");
fs::create_dir(&directory).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap();
let lock = directory.join("hardware-id.lock");
match case {
"symlink" => {
let target = temporary.path().join("target");
fs::write(&target, b"").unwrap();
symlink(target, &lock).unwrap();
}
"hard-link" => {
fs::write(&lock, b"").unwrap();
fs::set_permissions(&lock, fs::Permissions::from_mode(0o600)).unwrap();
fs::hard_link(&lock, temporary.path().join("second-link")).unwrap();
}
"permissions" => {
fs::write(&lock, b"").unwrap();
fs::set_permissions(&lock, fs::Permissions::from_mode(0o644)).unwrap();
}
_ => unreachable!(),
}
assert!(resolve_in(&directory, owner, anchor).is_err(), "accepted {case} lock");
}
let temporary = tempfile::tempdir().unwrap();
let directory = temporary.path().join("state");
fs::create_dir(&directory).unwrap();
fs::set_permissions(&directory, fs::Permissions::from_mode(0o500)).unwrap();
assert!(resolve_in(&directory, owner, anchor).is_err());
fs::set_permissions(&directory, fs::Permissions::from_mode(0o700)).unwrap();
}
#[test]
fn record_serializes_source_as_a_number_and_rejects_unknown_codes() {
let record = Record {
version: 1,
anchor: anchor().unwrap(),
};
let json = serde_json::to_value(&record).unwrap();
assert_eq!(json["anchor"]["source"], 1);
assert_eq!(
serde_json::to_string(&record).unwrap(),
r#"{"version":1,"anchor":{"hardware_id":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","source":1}}"#
);
for source in [0, 4] {
let json = serde_json::json!({
"version": 1,
"anchor": {
"hardware_id": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
"source": source
}
});
assert!(serde_json::from_value::<Record>(json).is_err());
}
}
}
-463
View File
@@ -1,463 +0,0 @@
use std::{
fs::{self, File, OpenOptions},
io::{Read, Write},
os::unix::fs::{MetadataExt, OpenOptionsExt, PermissionsExt},
path::{Path, PathBuf},
};
use anyhow::{Context, ensure};
use base64::{Engine, engine::general_purpose::STANDARD};
use gpapi::hip::HipApprovalStatus;
use serde::{Deserialize, Serialize};
use tempfile::Builder;
use uuid::Uuid;
#[cfg(target_os = "linux")]
pub const APPROVAL_DIRECTORY: &str = "/var/lib/gpclient/hip-approvals";
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
pub const APPROVAL_DIRECTORY: &str = "/var/db/gpclient/hip-approvals";
pub const MAX_SCRIPT_SIZE: usize = common::constants::MAX_HIP_SCRIPT_SIZE;
const MAX_METADATA_SIZE: u64 = 8 * 1024;
const METADATA_VERSION: u8 = 1;
const SCRIPT_NAME: &str = "script";
const METADATA_NAME: &str = "metadata.json";
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InstallRequest {
pub original_path: String,
pub contents_base64: String,
}
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct ApprovalInfo {
pub approval_id: String,
pub owner_uid: u32,
pub sha256: String,
pub original_path: String,
}
#[derive(Clone, Debug)]
pub struct ApprovedScript {
pub info: ApprovalInfo,
pub path: PathBuf,
}
#[derive(Deserialize, Serialize)]
struct StoredMetadata {
version: u8,
info: ApprovalInfo,
}
impl InstallRequest {
fn contents(&self) -> anyhow::Result<Vec<u8>> {
ensure!(self.original_path.len() <= 4096, "HIP script path is too long");
ensure!(
Path::new(&self.original_path).is_absolute(),
"HIP script path must be absolute"
);
ensure!(
!self.original_path.contains('\0'),
"HIP script path contains a NUL byte"
);
ensure!(
self.contents_base64.len() <= (MAX_SCRIPT_SIZE + 2).div_ceil(3) * 4,
"HIP script exceeds 1 MiB"
);
let contents = STANDARD
.decode(&self.contents_base64)
.context("Invalid HIP script content encoding")?;
ensure!(
!contents.is_empty() && contents.len() <= MAX_SCRIPT_SIZE,
"HIP script must be 1 MiB or smaller"
);
Ok(contents)
}
}
pub fn install(request: InstallRequest, approving_uid: u32) -> anyhow::Result<ApprovalInfo> {
ensure!(approving_uid != 0, "Root cannot approve a desktop HIP script");
let contents = request.contents()?;
let base = Path::new(APPROVAL_DIRECTORY);
fs::create_dir_all(base).context("Cannot create HIP approval directory")?;
validate_approval_ancestors(base)?;
fs::set_permissions(base, fs::Permissions::from_mode(0o700))?;
install_at(base, &contents, request.original_path, approving_uid, 0)
}
pub fn resolve(approval_id: &str, desktop_uid: u32) -> anyhow::Result<ApprovedScript> {
let budget = gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
resolve_with_control(approval_id, desktop_uid, &budget)
}
pub fn resolve_with_control(
approval_id: &str,
desktop_uid: u32,
control: &dyn gpapi::process::collection::CollectionControl,
) -> anyhow::Result<ApprovedScript> {
control.check()?;
ensure!(desktop_uid != 0, "Root is not a desktop HIP approval owner");
let base = Path::new(APPROVAL_DIRECTORY);
validate_approval_ancestors(base)?;
resolve_at_with_control(base, approval_id, desktop_uid, 0, control)
}
pub fn revoke(approval_id: &str, approving_uid: u32) -> anyhow::Result<()> {
ensure!(approving_uid != 0, "Root cannot revoke another user's HIP approval");
let base = Path::new(APPROVAL_DIRECTORY);
validate_approval_ancestors(base)?;
revoke_at(base, approval_id, approving_uid, 0)
}
pub fn status(approval_id: &str, desktop_uid: u32) -> anyhow::Result<HipApprovalStatus> {
status_at(Path::new(APPROVAL_DIRECTORY), approval_id, desktop_uid, 0, true)
}
fn status_at(
base: &Path,
approval_id: &str,
desktop_uid: u32,
file_owner: u32,
validate_root_ancestors: bool,
) -> anyhow::Result<HipApprovalStatus> {
ensure!(desktop_uid != 0, "HIP approval status requires a desktop user");
validate_id(approval_id)?;
for path in [
base.to_path_buf(),
base.join(approval_id),
base.join(approval_id).join(METADATA_NAME),
] {
match fs::symlink_metadata(&path) {
Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(HipApprovalStatus::Revoked),
Err(_) => return Ok(HipApprovalStatus::Corrupt),
Ok(_) => {}
}
}
if validate_private_dir(base, file_owner).is_err()
|| (validate_root_ancestors && validate_approval_ancestors(base).is_err())
{
return Ok(HipApprovalStatus::Corrupt);
}
let info = match read_metadata_unbound_at(base, approval_id, file_owner) {
Ok(info) => info,
Err(_) => return Ok(HipApprovalStatus::Corrupt),
};
if info.owner_uid != desktop_uid {
return Ok(HipApprovalStatus::OtherUser);
}
Ok(if resolve_at(base, approval_id, desktop_uid, file_owner).is_ok() {
HipApprovalStatus::Valid
} else {
HipApprovalStatus::Corrupt
})
}
fn install_at(
base: &Path,
contents: &[u8],
original_path: String,
approving_uid: u32,
file_owner: u32,
) -> anyhow::Result<ApprovalInfo> {
validate_private_dir(base, file_owner)?;
ensure!(
!contents.is_empty() && contents.len() <= MAX_SCRIPT_SIZE,
"HIP script must be 1 MiB or smaller"
);
let approval_id = Uuid::new_v4().to_string();
let info = ApprovalInfo {
approval_id: approval_id.clone(),
owner_uid: approving_uid,
sha256: sha256::digest(contents),
original_path,
};
let staged = Builder::new().prefix(".install-").tempdir_in(base)?;
fs::set_permissions(staged.path(), fs::Permissions::from_mode(0o700))?;
validate_private_dir(staged.path(), file_owner)?;
let script = staged.path().join(SCRIPT_NAME);
write_new(&script, contents, 0o500)?;
let metadata = staged.path().join(METADATA_NAME);
let stored = StoredMetadata {
version: METADATA_VERSION,
info: info.clone(),
};
let encoded = serde_json::to_vec(&stored)?;
ensure!(
encoded.len() as u64 <= MAX_METADATA_SIZE,
"HIP approval metadata is too large"
);
write_new(&metadata, &encoded, 0o600)?;
File::open(staged.path())?.sync_all()?;
let target = base.join(&approval_id);
ensure!(!target.exists(), "HIP approval ID collision");
fs::rename(staged.path(), &target).context("Cannot publish HIP approval")?;
File::open(base)?.sync_all()?;
Ok(info)
}
fn resolve_at(base: &Path, approval_id: &str, desktop_uid: u32, file_owner: u32) -> anyhow::Result<ApprovedScript> {
let budget = gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
resolve_at_with_control(base, approval_id, desktop_uid, file_owner, &budget)
}
fn resolve_at_with_control(
base: &Path,
approval_id: &str,
desktop_uid: u32,
file_owner: u32,
control: &dyn gpapi::process::collection::CollectionControl,
) -> anyhow::Result<ApprovedScript> {
control.check()?;
let info = read_metadata_at(base, approval_id, desktop_uid, file_owner)?;
control.check()?;
let script = base.join(approval_id).join(SCRIPT_NAME);
validate_file(&script, file_owner, 0o500, MAX_SCRIPT_SIZE as u64)?;
let mut file = File::open(&script)?;
let mut contents = Vec::new();
let mut chunk = [0_u8; 8192];
loop {
control.check()?;
let read = file.read(&mut chunk)?;
if read == 0 {
break;
}
ensure!(
contents.len() + read <= MAX_SCRIPT_SIZE,
"Approved HIP script is too large"
);
contents.extend_from_slice(&chunk[..read]);
}
ensure!(!contents.is_empty(), "Approved HIP script is empty");
ensure!(
sha256::digest(&contents) == info.sha256,
"Approved HIP script digest mismatch"
);
control.check()?;
Ok(ApprovedScript { info, path: script })
}
fn read_metadata_at(base: &Path, approval_id: &str, desktop_uid: u32, file_owner: u32) -> anyhow::Result<ApprovalInfo> {
let info = read_metadata_unbound_at(base, approval_id, file_owner)?;
ensure!(info.owner_uid == desktop_uid, "HIP approval belongs to another user");
Ok(info)
}
fn read_metadata_unbound_at(base: &Path, approval_id: &str, file_owner: u32) -> anyhow::Result<ApprovalInfo> {
validate_id(approval_id)?;
validate_private_dir(base, file_owner)?;
let directory = base.join(approval_id);
validate_private_dir(&directory, file_owner)?;
let metadata_path = directory.join(METADATA_NAME);
validate_file(&metadata_path, file_owner, 0o600, MAX_METADATA_SIZE)?;
let stored: StoredMetadata = serde_json::from_slice(&fs::read(metadata_path)?)?;
ensure!(stored.version == METADATA_VERSION, "Unsupported HIP approval version");
ensure!(stored.info.approval_id == approval_id, "HIP approval ID mismatch");
ensure!(
stored.info.sha256.len() == 64 && stored.info.sha256.bytes().all(|byte| byte.is_ascii_hexdigit()),
"Invalid HIP approval digest"
);
Ok(stored.info)
}
fn revoke_at(base: &Path, approval_id: &str, approving_uid: u32, file_owner: u32) -> anyhow::Result<()> {
validate_id(approval_id)?;
let directory = base.join(approval_id);
// The GUI may retry after removal succeeds but saving its settings fails.
if let Err(err) = fs::symlink_metadata(&directory) {
if err.kind() == std::io::ErrorKind::NotFound {
return Ok(());
}
return Err(err).context("Cannot inspect HIP approval directory");
}
read_metadata_at(base, approval_id, approving_uid, file_owner)?;
// Renaming first makes revocation atomic for the runner. Cleanup is separate:
// a failed cleanup cannot make this approval executable again.
let revoked = base.join(format!(".revoked-{approval_id}"));
fs::rename(&directory, &revoked).context("Cannot revoke HIP approval")?;
File::open(base)?.sync_all()?;
if let Err(err) = fs::remove_dir_all(&revoked) {
log::warn!("HIP approval was revoked but its snapshot could not be removed: {err}");
} else {
File::open(base)?.sync_all()?;
}
Ok(())
}
fn write_new(path: &Path, bytes: &[u8], mode: u32) -> anyhow::Result<()> {
let mut file = OpenOptions::new().write(true).create_new(true).mode(mode).open(path)?;
file.write_all(bytes)?;
file.sync_all()?;
Ok(())
}
fn validate_id(value: &str) -> anyhow::Result<()> {
let parsed = Uuid::parse_str(value).context("Invalid HIP approval ID")?;
ensure!(parsed.to_string() == value, "HIP approval ID must use canonical form");
Ok(())
}
fn validate_private_dir(path: &Path, owner_uid: u32) -> anyhow::Result<()> {
let metadata = fs::symlink_metadata(path).with_context(|| format!("Cannot inspect {}", path.display()))?;
ensure!(
metadata.is_dir() && !metadata.file_type().is_symlink(),
"HIP approval directory is not a directory"
);
ensure!(
metadata.uid() == owner_uid && metadata.permissions().mode() & 0o077 == 0,
"HIP approval directory {} is not private (owner {}, mode {:o})",
path.display(),
metadata.uid(),
metadata.permissions().mode() & 0o777
);
Ok(())
}
fn validate_file(path: &Path, owner_uid: u32, mode: u32, max_size: u64) -> anyhow::Result<()> {
let metadata = fs::symlink_metadata(path).with_context(|| format!("Cannot inspect {}", path.display()))?;
ensure!(
metadata.is_file() && !metadata.file_type().is_symlink(),
"HIP approval file is not regular"
);
ensure!(
metadata.uid() == owner_uid && metadata.permissions().mode() & 0o777 == mode,
"HIP approval file has unsafe ownership or mode"
);
ensure!(metadata.len() <= max_size, "HIP approval file is too large");
Ok(())
}
/// Check every component because a trusted file below a writable parent can
/// be replaced before a later HIP refresh.
fn validate_approval_ancestors(path: &Path) -> anyhow::Result<()> {
ensure!(path.is_absolute(), "HIP approval path must be absolute");
for component in path.ancestors().take_while(|part| part.as_os_str() != "/") {
let metadata =
fs::symlink_metadata(component).with_context(|| format!("Cannot inspect {}", component.display()))?;
ensure!(
!metadata.file_type().is_symlink(),
"HIP approval path contains a symlink"
);
ensure!(metadata.uid() == 0, "HIP approval path is not root-owned");
ensure!(
metadata.permissions().mode() & 0o022 == 0,
"HIP approval path is writable by another user"
);
ensure!(metadata.is_dir(), "HIP approval parent is not a directory");
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn fixture() -> (tempfile::TempDir, u32) {
let base = tempfile::tempdir().unwrap();
fs::set_permissions(base.path(), fs::Permissions::from_mode(0o700)).unwrap();
let owner = fs::symlink_metadata(base.path()).unwrap().uid();
(base, owner)
}
#[test]
fn install_request_rejects_oversized_or_relative_script() {
let request = InstallRequest {
original_path: "hip.sh".into(),
contents_base64: STANDARD.encode(b"#!/bin/sh\n"),
};
assert!(request.contents().is_err());
let oversized = InstallRequest {
original_path: "/home/user/hip.sh".into(),
contents_base64: STANDARD.encode(vec![b'x'; MAX_SCRIPT_SIZE + 1]),
};
assert!(oversized.contents().is_err());
}
#[test]
fn approval_binds_owner_and_exact_script_digest() {
let (base, owner) = fixture();
let info = install_at(
base.path(),
b"#!/bin/sh\necho ok\n",
"/home/user/hip.sh".into(),
1000,
owner,
)
.unwrap();
let approved = resolve_at(base.path(), &info.approval_id, 1000, owner).unwrap();
assert_eq!(approved.info.sha256, info.sha256);
assert!(resolve_at(base.path(), &info.approval_id, 1001, owner).is_err());
fs::set_permissions(&approved.path, fs::Permissions::from_mode(0o700)).unwrap();
fs::write(&approved.path, b"#!/bin/sh\necho changed\n").unwrap();
fs::set_permissions(&approved.path, fs::Permissions::from_mode(0o500)).unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
}
#[test]
fn revoked_approval_is_unavailable() {
let (base, owner) = fixture();
let info = install_at(base.path(), b"#!/bin/sh\n", "/home/user/hip.sh".into(), 1000, owner).unwrap();
assert!(revoke_at(base.path(), &info.approval_id, 1001, owner).is_err());
revoke_at(base.path(), &info.approval_id, 1000, owner).unwrap();
revoke_at(base.path(), &info.approval_id, 1000, owner).unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
}
#[test]
fn status_distinguishes_owner_corruption_and_revocation() {
let (base, owner) = fixture();
let info = install_at(
base.path(),
b"#!/bin/sh\necho ok\n",
"/home/user/hip.sh".into(),
1000,
owner,
)
.unwrap();
assert_eq!(
status_at(base.path(), &info.approval_id, 1000, owner, false).unwrap(),
HipApprovalStatus::Valid
);
assert_eq!(
status_at(base.path(), &info.approval_id, 1001, owner, false).unwrap(),
HipApprovalStatus::OtherUser
);
let script = base.path().join(&info.approval_id).join(SCRIPT_NAME);
fs::set_permissions(&script, fs::Permissions::from_mode(0o700)).unwrap();
assert_eq!(
status_at(base.path(), &info.approval_id, 1000, owner, false).unwrap(),
HipApprovalStatus::Corrupt
);
fs::remove_file(base.path().join(&info.approval_id).join(METADATA_NAME)).unwrap();
assert_eq!(
status_at(base.path(), &info.approval_id, 1000, owner, false).unwrap(),
HipApprovalStatus::Revoked
);
}
#[test]
fn revoke_succeeds_if_script_was_corrupted() {
let (base, owner) = fixture();
let info = install_at(base.path(), b"#!/bin/sh\n", "/home/user/hip.sh".into(), 1000, owner).unwrap();
let script = base.path().join(&info.approval_id).join(SCRIPT_NAME);
fs::set_permissions(&script, fs::Permissions::from_mode(0o700)).unwrap();
fs::write(&script, b"changed").unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
revoke_at(base.path(), &info.approval_id, 1000, owner).unwrap();
assert!(!base.path().join(&info.approval_id).exists());
}
#[test]
fn rejects_symlinked_script() {
use std::os::unix::fs::symlink;
let (base, owner) = fixture();
let info = install_at(base.path(), b"#!/bin/sh\n", "/home/user/hip.sh".into(), 1000, owner).unwrap();
let script = base.path().join(&info.approval_id).join(SCRIPT_NAME);
fs::remove_file(&script).unwrap();
symlink("/bin/sh", &script).unwrap();
assert!(resolve_at(base.path(), &info.approval_id, 1000, owner).is_err());
}
}
-309
View File
@@ -1,309 +0,0 @@
use std::{collections::HashMap, io, sync::Arc, time::Duration};
use anyhow::{Context, bail, ensure};
use gpapi::{
hip::HipSource,
os_profile::HostIdentity,
service::{
request::PreviewHipReportRequest,
transport::{ServiceErrorCode, ServiceResult},
},
};
use openconnect::HipRequest;
use tokio::{
sync::{Mutex, Semaphore},
task::JoinHandle,
};
use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use crate::{session_registry::SessionRegistry, ws_connection::ConnectionControl};
const PREVIEW_TIMEOUT: Duration = Duration::from_secs(60);
const MAX_ACTIVE_PREVIEWS: usize = 4;
struct PreviewTask {
connection_id: Uuid,
cancellation: CancellationToken,
worker: JoinHandle<()>,
}
pub(crate) struct PreviewJob {
pub session_id: Uuid,
pub request_id: Uuid,
pub request: PreviewHipReportRequest,
pub edited_report: Option<Arc<str>>,
pub desktop_uid: Option<u32>,
pub identity: HostIdentity,
pub registry: Arc<SessionRegistry>,
pub connection: ConnectionControl,
}
pub(crate) struct HipPreviews {
tasks: Mutex<HashMap<Uuid, PreviewTask>>,
slots: Arc<Semaphore>,
shutdown: CancellationToken,
}
impl HipPreviews {
pub(crate) fn new() -> Self {
Self {
tasks: Mutex::new(HashMap::new()),
slots: Arc::new(Semaphore::new(MAX_ACTIVE_PREVIEWS)),
shutdown: CancellationToken::new(),
}
}
pub(crate) async fn start(&self, job: PreviewJob) -> bool {
let PreviewJob {
session_id,
request_id,
request,
edited_report,
desktop_uid,
identity,
registry,
connection,
} = job;
let mut tasks = self.tasks.lock().await;
if self.shutdown.is_cancelled() || tasks.get(&session_id).is_some_and(|task| !task.worker.is_finished()) {
return false;
}
if let Some(completed) = tasks.remove(&session_id) {
let _ = completed.worker.await;
}
let Ok(slot) = Arc::clone(&self.slots).try_acquire_owned() else {
return false;
};
let cancellation = self.shutdown.child_token();
let worker_cancellation = cancellation.clone();
let connection_id = connection.connection_id();
let worker = tokio::spawn(async move {
let _slot = slot;
let generated = tokio::task::spawn_blocking(move || {
generate(request, edited_report, desktop_uid, identity, worker_cancellation)
})
.await;
let result = match generated {
Ok(Ok(xml)) => preview_result(&registry, session_id, xml),
Ok(Err(error)) => {
log::warn!("HIP preview failed: {error:#}");
ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview failed")
}
Err(error) => {
log::warn!("HIP preview worker failed: {error}");
ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview failed")
}
};
// A bounded connection queue must not prevent preview teardown.
let _ = connection.send(crate::ws_connection::ConnectionCommand::Reply { id: request_id, result });
});
tasks.insert(
session_id,
PreviewTask {
connection_id,
cancellation,
worker,
},
);
true
}
pub(crate) async fn cancel_connection(&self, session_id: Uuid, connection_id: Uuid) {
let mut tasks = self.tasks.lock().await;
if !tasks
.get(&session_id)
.is_some_and(|task| task.connection_id == connection_id)
{
return;
}
if let Some(task) = tasks.remove(&session_id) {
task.cancellation.cancel();
let _ = task.worker.await;
}
}
pub(crate) async fn shutdown(&self) {
self.shutdown.cancel();
let tasks = std::mem::take(&mut *self.tasks.lock().await);
for task in tasks.into_values() {
let _ = task.worker.await;
}
}
}
fn preview_result(registry: &SessionRegistry, session_id: Uuid, xml: String) -> ServiceResult {
let result = registry.store_hip_preview(session_id, xml).and_then(|preview_id| {
registry
.hip_preview_chunk(session_id, preview_id, 0)
.map(|(xml, complete)| ServiceResult::HipPreviewChunk {
preview_id: preview_id.to_string(),
offset: 0,
xml,
complete,
})
});
result.unwrap_or_else(|_| ServiceResult::rejected(ServiceErrorCode::Internal, "HIP preview is unavailable"))
}
fn generate(
request: PreviewHipReportRequest,
edited_report: Option<Arc<str>>,
desktop_uid: Option<u32>,
identity: HostIdentity,
cancellation: CancellationToken,
) -> anyhow::Result<String> {
ensure!(request.client_version.len() <= 64, "Invalid HIP client version");
ensure!(
request.host_id.as_ref().is_none_or(|id| id.len() <= 256),
"Invalid HIP host ID"
);
let budget = gpapi::process::collection::CollectionBudget::new(PREVIEW_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(io::ErrorKind::Interrupted, "HIP preview cancelled"));
}
gpapi::process::collection::CollectionControl::check(&budget)
};
check()?;
let profile = crate::hip_source::profile(
&identity,
request.client_os,
Some(request.client_version.clone()),
None,
request.host_id.clone(),
None,
&check,
)?;
let input = HipRequest {
cookie: "user=preview&domain=preview&computer=preview".into(),
client_ip: Some("192.0.2.1".into()),
client_ipv6: None,
md5: "00000000000000000000000000000000".into(),
client_version: request.client_version,
client_os: request.client_os.as_str().into(),
os_version: profile.os_version().into(),
host_id: request.host_id,
local_hostname: Some(profile.computer().into()),
};
let xml = match &request.source {
HipSource::Disabled => bail!("HIP is disabled"),
HipSource::Generated => crate::hip_source::generate(&profile, None, &input, &check, true)?,
HipSource::Edited { .. } => {
let xml = edited_report.context("Edited HIP report is unavailable")?;
crate::hip_source::generate(&profile, Some(&xml), &input, &check, true)?
}
source => {
let execution = crate::hip_source::resolve(source, desktop_uid, false, None, Some(profile))?;
let openconnect::HipSource::Script(script) = execution.source else {
bail!("HIP preview executable is unavailable");
};
let xml = script.collect(&input, &check)?;
gphip::validate_edited_report(&xml).context("Custom HIP script did not emit a valid HIP report")?;
xml
}
};
check()?;
Ok(xml)
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::os_profile::ClientOs;
use std::sync::atomic::{AtomicBool, Ordering};
fn job(session_id: Uuid) -> PreviewJob {
let (tx, _) = tokio::sync::mpsc::channel(1);
let (connection, _) = ConnectionControl::new(Uuid::new_v4(), tx);
PreviewJob {
session_id,
request_id: Uuid::new_v4(),
request: PreviewHipReportRequest {
source: HipSource::Generated,
client_os: ClientOs::Linux,
client_version: "6.3.3".into(),
host_id: None,
},
edited_report: None,
desktop_uid: None,
identity: HostIdentity::from_parts(
"device".into(),
"host".into(),
"serial".into(),
"00:11:22:33:44:55".into(),
),
registry: Arc::new(SessionRegistry::new(Uuid::new_v4())),
connection,
}
}
#[tokio::test]
async fn preview_admission_rejects_duplicate_session_and_global_capacity() {
let previews = HipPreviews::new();
let session_id = Uuid::new_v4();
let cancellation = previews.shutdown.child_token();
let worker_cancellation = cancellation.clone();
let worker = tokio::spawn(async move { worker_cancellation.cancelled().await });
let connection_id = Uuid::new_v4();
previews.tasks.lock().await.insert(
session_id,
PreviewTask {
connection_id,
cancellation,
worker,
},
);
assert!(!previews.start(job(session_id)).await);
previews.cancel_connection(session_id, connection_id).await;
let _all_slots = Arc::clone(&previews.slots)
.acquire_many_owned(MAX_ACTIVE_PREVIEWS as u32)
.await
.unwrap();
assert!(!previews.start(job(Uuid::new_v4())).await);
previews.shutdown().await;
}
#[tokio::test]
async fn closing_preview_owner_waits_for_worker_teardown() {
let previews = HipPreviews::new();
let session_id = Uuid::new_v4();
let connection_id = Uuid::new_v4();
let cancellation = previews.shutdown.child_token();
let worker_cancellation = cancellation.clone();
let stopped = Arc::new(AtomicBool::new(false));
let worker_stopped = Arc::clone(&stopped);
let worker = tokio::spawn(async move {
worker_cancellation.cancelled().await;
tokio::task::yield_now().await;
worker_stopped.store(true, Ordering::SeqCst);
});
previews.tasks.lock().await.insert(
session_id,
PreviewTask {
connection_id,
cancellation,
worker,
},
);
previews.cancel_connection(session_id, Uuid::new_v4()).await;
assert!(!stopped.load(Ordering::SeqCst));
previews.cancel_connection(session_id, connection_id).await;
assert!(stopped.load(Ordering::SeqCst));
assert!(previews.tasks.lock().await.is_empty());
previews.shutdown().await;
assert!(!previews.start(job(session_id)).await);
}
#[test]
fn cancelled_preview_does_not_start_collection() {
let preview = job(Uuid::new_v4());
let cancelled = CancellationToken::new();
cancelled.cancel();
let error = generate(preview.request, None, None, preview.identity, cancelled).unwrap_err();
assert_eq!(
error.downcast_ref::<io::Error>().unwrap().kind(),
io::ErrorKind::Interrupted
);
}
}
-277
View File
@@ -1,277 +0,0 @@
use std::{fs, io, os::unix::fs::PermissionsExt, path::PathBuf, sync::Arc};
use anyhow::{Context, ensure};
use gpapi::{
hip::HipSource,
os_profile::{ClientOs, HostIdentity, OsProfile, OsProfileBuilder},
};
use gphip::{ReportContext, ReportInput};
use openconnect::{HipRequest, HipScript, HipScriptEnvironment};
pub(crate) struct HipExecution {
pub source: openconnect::HipSource,
approval: HipApproval,
}
impl HipExecution {
pub(crate) fn into_parts(self) -> (openconnect::HipSource, HipApproval) {
(self.source, self.approval)
}
}
pub(crate) struct HipApproval {
identity: Option<(String, u32)>,
}
impl HipApproval {
pub(crate) fn approval_is_valid(&self) -> bool {
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
if let Some((id, uid)) = &self.identity {
return gpservice::hip_approval::resolve(id, *uid).is_ok();
}
self.identity.is_none()
}
}
pub(crate) fn resolve(
source: &HipSource,
desktop_uid: Option<u32>,
brokered_macos: bool,
edited_report: Option<Arc<str>>,
profile: Option<OsProfile>,
) -> anyhow::Result<HipExecution> {
let approval;
let source = match source {
HipSource::Disabled => {
approval = None;
openconnect::HipSource::Disabled
}
HipSource::Generated | HipSource::Edited { .. } => {
let profile = profile.context("HIP generator identity is unavailable")?;
approval = None;
let xml = match source {
HipSource::Edited { .. } => {
let xml = edited_report.context("Edited HIP report was not uploaded for this connection")?;
gphip::validate_edited_report(&xml)?;
Some(xml)
}
_ => None,
};
openconnect::HipSource::Generator(Arc::new(move |request, control| {
generate(&profile, xml.as_deref(), request, &|| control.check(), false).map_err(generation_error)
}))
}
HipSource::UserScript { path } => {
approval = None;
ensure_custom_available(brokered_macos)?;
let uid = desktop_uid.context("HIP custom scripts require a verified desktop user")?;
ensure!(uid != 0, "HIP custom scripts require a non-root desktop user");
let path = PathBuf::from(path);
ensure!(path.is_absolute(), "HIP custom script path must be absolute");
let metadata = fs::symlink_metadata(&path).context("Failed to inspect the HIP script")?;
ensure!(
metadata.is_file() && !metadata.file_type().is_symlink() && metadata.permissions().mode() & 0o111 != 0,
"HIP custom script must be an executable regular file"
);
let script =
HipScript::new(path.to_string_lossy().into_owned(), Some(uid))?.with_environment(script_environment(uid)?)?;
openconnect::HipSource::Script(script)
}
HipSource::ApprovedRootScript { approval_id } => {
ensure_custom_available(brokered_macos)?;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
let owner_uid = desktop_uid.context("Root HIP scripts require a verified desktop user")?;
let approved = gpservice::hip_approval::resolve(approval_id, owner_uid)?;
let id = approval_id.clone();
let path = approved.path;
let expected = path.clone();
let script = HipScript::new(path.to_string_lossy().into_owned(), Some(0))?
.with_environment(script_environment(0)?)?
.with_validator(move |control| {
control.check()?;
let current = gpservice::hip_approval::resolve_with_control(&id, owner_uid, &|| control.check())
.map_err(generation_error)?;
if current.path != expected {
return Err(io::Error::other("Approved HIP executable changed"));
}
control.check()
});
approval = Some((approval_id.clone(), owner_uid));
openconnect::HipSource::Script(script)
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
{
let _ = (approval_id, desktop_uid);
anyhow::bail!("Root HIP script approvals are unavailable on this platform")
}
}
};
Ok(HipExecution {
source,
approval: HipApproval { identity: approval },
})
}
fn ensure_custom_available(brokered_macos: bool) -> anyhow::Result<()> {
ensure!(
!cfg!(target_os = "macos") && !brokered_macos,
"Custom HIP scripts are unavailable on macOS"
);
Ok(())
}
pub(crate) fn generate(
profile: &OsProfile,
edited: Option<&str>,
request: &HipRequest,
control: &dyn gpapi::process::collection::CollectionControl,
preview: bool,
) -> anyhow::Result<String> {
control.check()?;
let context = if preview {
ReportContext::Preview
} else {
ReportContext::Connected {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
}
};
let input = ReportInput {
profile: profile.clone(),
context,
};
match edited {
Some(xml) => gphip::refresh_edited_report_with_control(xml, &input, control),
None => gphip::generate_report_with_control(&input, control),
}
}
pub(crate) fn script_environment(uid: u32) -> anyhow::Result<HipScriptEnvironment> {
let user =
nix::unistd::User::from_uid(nix::unistd::Uid::from_raw(uid))?.context("HIP execution user is unavailable")?;
let home = user.dir.to_string_lossy().into_owned();
Ok(HipScriptEnvironment {
variables: vec![
(
"PATH".into(),
gpapi::process::collection::command_path(uid == 0)?
.into_string()
.map_err(|_| anyhow::anyhow!("HIP command path is not valid UTF-8"))?,
),
("LC_ALL".into(), "C".into()),
("HOME".into(), home.clone()),
("USER".into(), user.name.clone()),
("LOGNAME".into(), user.name),
],
cwd: home,
})
}
pub(crate) fn profile(
identity: &HostIdentity,
os: ClientOs,
version: Option<String>,
os_version: Option<String>,
host_id: Option<String>,
hostname: Option<String>,
control: &dyn gpapi::process::collection::CollectionControl,
) -> io::Result<OsProfile> {
let identity = HostIdentity::from_parts(
hostname.unwrap_or_else(|| identity.computer().into()),
host_id.unwrap_or_else(|| identity.host_id().into()),
identity.serialno().into(),
identity.mac_addr().into(),
);
let mut builder = OsProfileBuilder::new(os).host_identity(identity);
if let Some(version) = version {
builder = builder.client_version(version);
}
if let Some(os_version) = os_version {
builder = builder.os_version(os_version);
}
builder.build_with_control(control)
}
fn generation_error(error: anyhow::Error) -> io::Error {
match error.downcast::<io::Error>() {
Ok(error) => error,
Err(error) => io::Error::other(error),
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::os_profile::ClientOs;
fn fixture_profile() -> OsProfile {
profile(
&HostIdentity::from_parts(
"device".into(),
"host".into(),
"serial".into(),
"00:11:22:33:44:55".into(),
),
ClientOs::Linux,
Some("6.3.3".into()),
Some("negotiated-version".into()),
None,
None,
&gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
)
.unwrap()
}
#[test]
fn callback_configuration_needs_no_files_or_root_identity() {
let generated = resolve(&HipSource::Generated, None, true, None, Some(fixture_profile())).unwrap();
assert!(matches!(generated.source, openconnect::HipSource::Generator(_)));
let disabled = resolve(&HipSource::Disabled, None, true, None, Some(fixture_profile())).unwrap();
assert!(matches!(disabled.source, openconnect::HipSource::Disabled));
}
#[test]
fn profile_retains_negotiated_identity_and_os_version() {
let identity = HostIdentity::from_parts(
"original".into(),
"original-id".into(),
"serial".into(),
"00:11:22:33:44:55".into(),
);
let profile = profile(
&identity,
ClientOs::Mac,
Some("6.3.3".into()),
Some("negotiated-os".into()),
Some("negotiated-host".into()),
Some("negotiated-name".into()),
&gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
)
.unwrap();
assert_eq!(profile.os_version(), "negotiated-os");
assert_eq!(profile.host_identity().host_id(), "negotiated-host");
assert_eq!(profile.host_identity().computer(), "negotiated-name");
assert_eq!(profile.host_identity().serialno(), "serial");
}
#[test]
fn callback_errors_preserve_cancellation() {
let error = generation_error(io::Error::new(io::ErrorKind::Interrupted, "cancelled").into());
assert_eq!(error.kind(), io::ErrorKind::Interrupted);
}
#[test]
fn custom_source_cannot_run_on_macos_or_choose_root_without_approval() {
let source = HipSource::UserScript {
path: "/tmp/hip.sh".into(),
};
assert!(resolve(&source, None, false, None, None).is_err());
assert!(resolve(&source, Some(0), false, None, None).is_err());
assert!(resolve(&source, Some(1000), true, None, Some(fixture_profile())).is_err());
#[cfg(target_os = "macos")]
assert!(resolve(&source, Some(1000), false, None, None).is_err());
}
}
-2
View File
@@ -1,4 +1,2 @@
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub mod hip_approval;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub mod vpnc_script;
+1 -1
View File
@@ -45,7 +45,7 @@ impl CredentialServer {
}
let registry = Arc::clone(&self.registry);
tokio::spawn(async move {
if let Err(err) = credential_lease::serve(stream, registry, None).await {
if let Err(err) = credential_lease::serve(stream, registry).await {
warn!("Broker credential lease ended: {err}");
}
});
-5
View File
@@ -1,14 +1,9 @@
mod cli;
#[cfg(all(unix, any(target_os = "macos", debug_assertions)))]
mod credential_lease;
mod desktop_client;
#[cfg(debug_assertions)]
mod dev_bootstrap;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", all(test, unix)))]
mod device_anchor;
mod handlers;
mod hip_preview;
mod hip_source;
#[cfg(target_os = "macos")]
mod macos_broker;
mod request_dispatcher;
+46 -215
View File
@@ -9,7 +9,7 @@ use std::{
use common::binary_paths;
use gpapi::{
service::{
request::{UpdateGuiRequest, UpdateLogLevelRequest, WsRequest},
request::{UpdateGuiRequest, WsRequest},
transport::{ServiceErrorCode, ServiceResult},
},
utils::{checksum::verify_checksum, redact::Redaction},
@@ -17,63 +17,15 @@ use gpapi::{
use log::{info, warn};
use tar::Archive;
use tempfile::NamedTempFile;
use tokio::sync::Mutex;
use tokio::sync::{Mutex, mpsc};
use xz2::read::XzDecoder;
const MAX_GUI_ARCHIVE_SIZE: u64 = 256 * 1024 * 1024;
const MAX_GUI_ARCHIVE_CONTENT_SIZE: u64 = 512 * 1024 * 1024;
const MAX_GUI_BINARY_SIZE: u64 = 256 * 1024 * 1024;
pub(crate) struct SessionAuthority {
pub registry: Arc<crate::session_registry::SessionRegistry>,
pub session_id: uuid::Uuid,
pub generation: u64,
}
pub(crate) enum PendingDispatch {
Connect {
preparation: ConnectionPreparation,
request: Box<gpapi::service::request::ConnectRequest>,
desktop_uid: Option<u32>,
edited_report: Option<Arc<str>>,
},
Drain(Option<crate::vpn_task::AttemptDrain>),
Other(WsRequest),
}
pub(crate) struct ConnectionPreparation {
authority: SessionAuthority,
non_tunnel: bool,
reservation: Option<crate::vpn_task::ConnectReservation>,
}
impl ConnectionPreparation {
fn cancellation(&self) -> tokio_util::sync::CancellationToken {
self
.reservation
.as_ref()
.expect("preparation retains reservation")
.cancellation()
}
fn commit(
mut self,
connection: crate::vpn_task::PreparedConnection,
desktop_uid: Option<u32>,
edited_report: Option<Arc<str>>,
) -> ServiceResult {
let reservation = self.reservation.take().expect("preparation retains reservation");
self.authority.registry.commit_connection(
self.authority.session_id,
self.authority.generation,
self.non_tunnel,
|| reservation.commit(connection, desktop_uid, edited_report, Some(self.authority.session_id)),
)
}
}
pub struct RequestDispatcher {
lifecycle: crate::vpn_task::LifecycleHandle,
ws_req_tx: mpsc::Sender<WsRequest>,
gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>,
install_lock: Mutex<()>,
@@ -83,14 +35,14 @@ pub struct RequestDispatcher {
impl RequestDispatcher {
pub fn new(
lifecycle: crate::vpn_task::LifecycleHandle,
ws_req_tx: mpsc::Sender<WsRequest>,
gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>,
gui_management_enabled: bool,
brokered_scripts_dir: Option<std::path::PathBuf>,
) -> Self {
Self {
lifecycle,
ws_req_tx,
gui_restart_requested,
redaction,
install_lock: Mutex::new(()),
@@ -99,130 +51,7 @@ impl RequestDispatcher {
}
}
pub fn dispatch_lifecycle(
&self,
request: WsRequest,
desktop_uid: Option<u32>,
edited_report: Option<Arc<str>>,
authority: Option<SessionAuthority>,
) -> Result<PendingDispatch, ServiceResult> {
match request {
WsRequest::Connect(request) => {
if let Err(message) = self.validate_connect_paths(&request) {
return Err(ServiceResult::rejected(ServiceErrorCode::InvalidRequest, message));
}
let redaction_values = request
.plan()
.members()
.iter()
.flat_map(|member| [member.gateway.server(), member.authentication.cookie()])
.collect::<Vec<_>>();
if let Err(err) = self.redaction.add_values(&redaction_values) {
warn!("Failed to update log redaction: {err}");
return Err(ServiceResult::rejected(
ServiceErrorCode::Internal,
"Request could not be accepted",
));
}
let authority = authority
.ok_or_else(|| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Connection session is missing"))?;
let non_tunnel = request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel);
let reservation =
authority
.registry
.reserve_connection(authority.session_id, authority.generation, non_tunnel, || {
self.lifecycle.reserve_connect()
})?;
let preparation = ConnectionPreparation {
authority,
non_tunnel,
reservation: Some(reservation),
};
let edited_report = if let gpapi::hip::HipSource::Edited { report_id } = request.args().hip_source() {
let report_id = uuid::Uuid::parse_str(report_id)
.map_err(|_| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report ID"))?;
Some(
preparation
.authority
.registry
.edited_hip_report(preparation.authority.session_id, report_id)
.map_err(|_| {
ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"HIP report is unavailable for this session",
)
})?,
)
} else {
edited_report
};
Ok(PendingDispatch::Connect {
preparation,
request,
desktop_uid,
edited_report,
})
}
WsRequest::StopNonTunnelAttachment { connection_id } => {
let authority = authority
.ok_or_else(|| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Connection session is missing"))?;
let drain =
authority
.registry
.stop_non_tunnel_attachment(authority.session_id, authority.generation, connection_id)?;
Ok(PendingDispatch::Drain(drain))
}
WsRequest::Disconnect(_) => Err(self.lifecycle.request_disconnect()),
request => Ok(PendingDispatch::Other(request)),
}
}
#[cfg(test)]
pub async fn dispatch(&self, request: WsRequest) -> ServiceResult {
match self.dispatch_lifecycle(request, None, None, None) {
Ok(request) => self.dispatch_pending(request).await,
Err(result) => result,
}
}
pub(crate) async fn dispatch_pending(&self, request: PendingDispatch) -> ServiceResult {
let request = match request {
PendingDispatch::Connect {
preparation,
request,
desktop_uid,
edited_report,
} => {
let prepared = crate::vpn_task::prepare_connection(
*request,
self.brokered_scripts_dir.is_some(),
preparation.cancellation(),
)
.await;
return match prepared {
Ok(connection) => preparation.commit(connection, desktop_uid, edited_report),
Err(error) => {
warn!("Connection preparation failed: {error:#}");
ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"Connection resources could not be prepared",
)
}
};
}
PendingDispatch::Drain(drain) => {
if let Some(drain) = drain {
drain.wait().await;
}
return ServiceResult::Accepted;
}
PendingDispatch::Other(request) => request,
};
match request {
WsRequest::RestartGui => {
if !self.gui_management_enabled {
@@ -256,23 +85,29 @@ impl RequestDispatcher {
ServiceResult::VpncScriptMetadata(None)
}
}
WsRequest::UpdateLogLevel(UpdateLogLevelRequest(level)) => {
let level = level.parse().unwrap_or(log::Level::Info);
info!("Updating log level to: {level}");
if let Err(err) = gpapi::logger::set_max_level(level) {
warn!("Failed to update log level: {err}");
request => {
if let WsRequest::Connect(ref connect) = request {
if let Err(message) = self.validate_connect_paths(connect) {
return ServiceResult::rejected(ServiceErrorCode::InvalidRequest, message);
}
if let Err(err) = self
.redaction
.add_values(&[connect.gateway().server(), connect.args().cookie()])
{
warn!("Failed to update log redaction: {err}");
return ServiceResult::rejected(ServiceErrorCode::Internal, "Request could not be accepted");
}
}
match self.ws_req_tx.try_send(request) {
Ok(()) => ServiceResult::Accepted,
Err(mpsc::error::TrySendError::Full(_)) => {
ServiceResult::rejected(ServiceErrorCode::Busy, "Service request queue is full")
}
Err(mpsc::error::TrySendError::Closed(_)) => {
ServiceResult::rejected(ServiceErrorCode::Internal, "VPN task is unavailable")
}
}
ServiceResult::Accepted
}
WsRequest::Connect(_)
| WsRequest::StopNonTunnelAttachment { .. }
| WsRequest::Disconnect(_)
| WsRequest::StoreEditedHipReportChunk(_)
| WsRequest::PreviewHipReport(_)
| WsRequest::GetHipApprovalStatus { .. }
| WsRequest::ReadHipPreviewChunk(_)
| WsRequest::GetLastSubmittedHipReport => {
unreachable!("session-bound request was already dispatched")
}
}
}
@@ -282,14 +117,12 @@ impl RequestDispatcher {
return Ok(());
};
let expected_script = scripts.join("vpnc-script").to_string_lossy().into_owned();
let expected_wrapper = scripts.join("hipreport.sh").to_string_lossy().into_owned();
if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) {
return Err("macOS VPN script must be the bundled script");
}
if matches!(
request.args().hip_source(),
gpapi::hip::HipSource::UserScript { .. } | gpapi::hip::HipSource::ApprovedRootScript { .. }
) {
return Err("macOS does not support custom HIP scripts");
if request.args().csd_wrapper().as_deref() != Some(expected_wrapper.as_str()) {
return Err("macOS HIP wrapper must be the bundled wrapper");
}
if request.args().certificate().is_some() || request.args().sslkey().is_some() {
return Err("macOS client identity must be provided as protected data, not root-readable paths");
@@ -430,12 +263,14 @@ fn extract_gui_binary<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<N
#[cfg(test)]
mod tests {
use crate::vpn_task::test_connect_request as test_request;
use std::{io::Cursor, os::unix::fs::PermissionsExt};
use gpapi::{
gateway::Gateway,
service::transport::{ServiceErrorCode, ServiceResult},
service::{
request::ConnectRequest,
transport::{ServiceErrorCode, ServiceResult},
},
};
use tar::{Builder, EntryType, Header};
use xz2::write::XzEncoder;
@@ -544,8 +379,9 @@ mod tests {
#[tokio::test]
async fn brokered_mode_rejects_gui_management_and_root_readable_identity_paths() {
let (request_tx, _request_rx) = mpsc::channel(1);
let dispatcher = RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
request_tx,
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
false,
@@ -558,8 +394,9 @@ mod tests {
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let request = test_request(info)
let request = ConnectRequest::new(info, "cookie".into())
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string()))
.with_certificate(Some("/Users/example/client.pem".to_string()));
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else {
panic!("brokered mode accepted a root-readable identity path");
@@ -569,8 +406,9 @@ mod tests {
#[test]
fn brokered_mode_accepts_only_resource_script_paths() {
let (request_tx, _request_rx) = mpsc::channel(1);
let dispatcher = RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
request_tx,
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
false,
@@ -578,24 +416,17 @@ mod tests {
);
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let bundled =
test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()));
let bundled = ConnectRequest::new(info.clone(), "cookie".into())
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string()));
assert_eq!(dispatcher.validate_connect_paths(&bundled), Ok(()));
let old_layout = test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()));
let old_layout = ConnectRequest::new(info, "cookie".into())
.with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()))
.with_csd_wrapper(Some("/app/Contents/Helpers/hipreport.sh".to_string()));
assert_eq!(
dispatcher.validate_connect_paths(&old_layout),
Err("macOS VPN script must be the bundled script")
);
let custom = test_request(info)
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_hip_source(gpapi::hip::HipSource::UserScript {
path: "/tmp/hip.sh".into(),
});
assert_eq!(
dispatcher.validate_connect_paths(&custom),
Err("macOS does not support custom HIP scripts")
);
}
}
+2 -2
View File
@@ -1,3 +1,3 @@
pub(crate) fn desktop_uid() -> Option<u32> {
None
pub(crate) fn trusted_csd_uid() -> anyhow::Result<Option<u32>> {
Ok(None)
}
+1 -1
View File
@@ -5,4 +5,4 @@ mod platform;
#[path = "default.rs"]
mod platform;
pub(crate) use platform::desktop_uid;
pub(crate) use platform::trusted_csd_uid;
@@ -1,9 +1,7 @@
pub(crate) fn desktop_uid() -> Option<u32> {
match gpapi::process::users::get_non_root_user() {
Ok(user) => Some(user.uid()),
Err(err) => {
log::warn!("No verified desktop user is available for custom HIP scripts: {err}");
None
}
pub(crate) fn trusted_csd_uid() -> anyhow::Result<Option<u32>> {
let uid = gpapi::process::users::get_non_root_user()?.uid();
if uid == 0 {
anyhow::bail!("The HIP script user must not be root");
}
Ok(Some(uid))
}
+11 -553
View File
@@ -4,7 +4,7 @@ use std::{
time::{Duration, Instant},
};
use gpapi::service::transport::{ServiceErrorCode, ServiceResult, SessionCredential};
use gpapi::service::transport::SessionCredential;
use thiserror::Error;
use uuid::Uuid;
use zeroize::Zeroizing;
@@ -13,11 +13,9 @@ use crate::ws_connection::ConnectionControl;
const ACTIVATION_TIMEOUT: Duration = Duration::from_secs(15);
const MAX_PENDING_SESSIONS: usize = 16;
const HIP_PREVIEW_CHUNK_BYTES: usize = 16 * 1024;
pub struct HandshakePermit {
pub session_id: Uuid,
pub desktop_uid: Option<u32>,
pub observed_generation: u64,
pub secret: Zeroizing<[u8; 32]>,
token: Uuid,
@@ -40,13 +38,6 @@ pub enum SessionError {
ReconnectSuperseded,
#[error("session registry is unavailable")]
Unavailable,
#[error("invalid HIP report upload")]
InvalidHipUpload,
}
pub enum HipUploadResult {
Progress(Uuid),
Stored(Uuid),
}
enum SessionStatus {
@@ -62,132 +53,17 @@ enum SessionStatus {
}
struct SessionRecord {
non_tunnel: Option<AttachmentAttempt>,
closed_attachment: Option<Uuid>,
secret: Zeroizing<[u8; 32]>,
product_version: String,
desktop_uid: Option<u32>,
edited_hip_report: Option<(Uuid, Arc<str>)>,
edited_hip_upload: Option<(Uuid, String)>,
hip_preview: Option<(Uuid, Arc<str>)>,
last_successful_hip_report: Option<Arc<str>>,
status: SessionStatus,
}
/// Only live preparation/execution is retained, never acceptance history.
struct AttachmentAttempt {
generation: u64,
connection_id: Uuid,
drain: crate::vpn_task::AttemptDrain,
}
pub struct SessionRegistry {
service_instance_id: Uuid,
sessions: Mutex<HashMap<Uuid, SessionRecord>>,
}
fn unavailable_connection() -> ServiceResult {
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Connection attachment is unavailable")
}
fn current_connection(record: &SessionRecord, expected: u64) -> Result<Uuid, ServiceResult> {
match &record.status {
SessionStatus::Active {
generation,
connection: Some(connection),
..
} if *generation == expected && !connection.is_closed() => Ok(connection.connection_id()),
_ => Err(unavailable_connection()),
}
}
impl SessionRegistry {
pub(crate) fn reserve_connection(
&self,
session_id: Uuid,
generation: u64,
non_tunnel: bool,
reserve: impl FnOnce() -> Result<crate::vpn_task::ConnectReservation, ServiceResult>,
) -> Result<crate::vpn_task::ConnectReservation, ServiceResult> {
let mut sessions = self.sessions.lock().map_err(|_| unavailable_connection())?;
let record = sessions.get_mut(&session_id).ok_or_else(unavailable_connection)?;
let connection_id = current_connection(record, generation)?;
if non_tunnel && record.closed_attachment == Some(connection_id) {
return Err(ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"Non-tunnel attachment is closing",
));
}
if record
.non_tunnel
.as_ref()
.is_some_and(|attempt| attempt.drain.is_complete())
{
record.non_tunnel = None;
}
let reservation = reserve()?;
if non_tunnel {
record.non_tunnel = Some(AttachmentAttempt {
generation,
connection_id,
drain: reservation.drain(),
});
}
Ok(reservation)
}
pub(crate) fn commit_connection(
&self,
session_id: Uuid,
generation: u64,
non_tunnel: bool,
commit: impl FnOnce() -> ServiceResult,
) -> ServiceResult {
let Ok(sessions) = self.sessions.lock() else {
return unavailable_connection();
};
let Some(record) = sessions.get(&session_id) else {
return unavailable_connection();
};
if non_tunnel {
let connection_id = match current_connection(record, generation) {
Ok(id) => id,
Err(result) => return result,
};
if record.closed_attachment == Some(connection_id) {
return ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Non-tunnel attachment is closing");
}
} else if !matches!(record.status, SessionStatus::Active { .. }) {
return unavailable_connection();
}
// Non-tunnel attachment invalidation takes this same lock. An authorized
// tunnel reservation survives attachment loss as before; revoked sessions
// cannot commit either mode. Queue insertion transfers cleanup ownership.
commit()
}
pub(crate) fn stop_non_tunnel_attachment(
&self,
session_id: Uuid,
generation: u64,
connection_id: Uuid,
) -> Result<Option<crate::vpn_task::AttemptDrain>, ServiceResult> {
let mut sessions = self.sessions.lock().map_err(|_| unavailable_connection())?;
let record = sessions.get_mut(&session_id).ok_or_else(unavailable_connection)?;
let current_id = current_connection(record, generation)?;
if current_id == connection_id {
record.closed_attachment = Some(connection_id);
}
if let Some(attempt) = &record.non_tunnel {
if attempt.connection_id == connection_id {
attempt.drain.cancel();
return Ok(Some(attempt.drain.clone()));
}
}
// No retained live work belongs to that attachment. Never stop a successor.
Ok(None)
}
pub fn new(service_instance_id: Uuid) -> Self {
Self {
service_instance_id,
@@ -195,7 +71,7 @@ impl SessionRegistry {
}
}
pub fn issue(&self, product_version: &str, desktop_uid: Option<u32>) -> Result<Arc<SessionCredential>, SessionError> {
pub fn issue(&self, product_version: &str) -> Result<Arc<SessionCredential>, SessionError> {
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let now = Instant::now();
sessions.retain(|_, record| {
@@ -214,31 +90,14 @@ impl SessionRegistry {
return Err(SessionError::TooManyPending);
}
let credential =
SessionCredential::generate(self.service_instance_id, product_version).map_err(|_| SessionError::Unavailable)?;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
let credential = {
let anchor = crate::device_anchor::resolve().map_err(|error| {
log::warn!("GUI device anchor unavailable: {error:#}");
SessionError::Unavailable
})?;
credential
.with_device_anchor(anchor)
.map_err(|_| SessionError::Unavailable)?
};
let credential = Arc::new(credential);
let credential = Arc::new(
SessionCredential::generate(self.service_instance_id, product_version).map_err(|_| SessionError::Unavailable)?,
);
sessions.insert(
credential.session_id(),
SessionRecord {
non_tunnel: None,
closed_attachment: None,
secret: Zeroizing::new(*credential.secret()),
product_version: credential.product_version().to_owned(),
desktop_uid,
edited_hip_report: None,
edited_hip_upload: None,
hip_preview: None,
last_successful_hip_report: None,
status: SessionStatus::Pending {
activation_deadline: Instant::now() + ACTIVATION_TIMEOUT,
handshake_token: None,
@@ -317,7 +176,6 @@ impl SessionRegistry {
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
Ok(HandshakePermit {
session_id,
desktop_uid: record.desktop_uid,
observed_generation,
secret: Zeroizing::new(*record.secret),
token,
@@ -370,10 +228,6 @@ impl SessionRegistry {
connection: current,
reconnect_token,
} if *generation == permit.observed_generation && *reconnect_token == Some(permit.token) => {
if let Some(attempt) = &record.non_tunnel {
attempt.drain.cancel();
}
record.closed_attachment = None;
*generation = generation.checked_add(1).ok_or(SessionError::Unavailable)?;
*reconnect_token = None;
Ok(current.replace(connection))
@@ -414,133 +268,10 @@ impl SessionRegistry {
)
}
pub fn append_edited_hip_report_chunk(
&self,
session_id: Uuid,
upload_id: Option<Uuid>,
offset: usize,
chunk: String,
complete: bool,
) -> Result<HipUploadResult, SessionError> {
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get_mut(&session_id).ok_or(SessionError::Unauthorized)?;
if !matches!(record.status, SessionStatus::Active { .. }) {
return Err(SessionError::Unauthorized);
}
if upload_id.is_none() {
if offset != 0 {
return Err(SessionError::InvalidHipUpload);
}
record.edited_hip_upload = Some((Uuid::new_v4(), String::new()));
}
let (current_id, xml) = record
.edited_hip_upload
.as_mut()
.ok_or(SessionError::InvalidHipUpload)?;
if upload_id.is_some_and(|id| id != *current_id) || offset != xml.len() || chunk.len() > 8 * 1024 {
return Err(SessionError::InvalidHipUpload);
}
if xml.len() + chunk.len() > gphip::MAX_EDITED_REPORT_BYTES {
record.edited_hip_upload = None;
return Err(SessionError::InvalidHipUpload);
}
xml.push_str(&chunk);
if !complete {
return Ok(HipUploadResult::Progress(*current_id));
}
if gphip::validate_edited_report(xml).is_err() {
record.edited_hip_upload = None;
return Err(SessionError::InvalidHipUpload);
}
let (_, xml) = record.edited_hip_upload.take().ok_or(SessionError::InvalidHipUpload)?;
let report_id = Uuid::new_v4();
record.edited_hip_report = Some((report_id, Arc::from(xml)));
Ok(HipUploadResult::Stored(report_id))
}
pub fn edited_hip_report(&self, session_id: Uuid, report_id: Uuid) -> Result<Arc<str>, SessionError> {
let sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
record
.edited_hip_report
.as_ref()
.filter(|(id, _)| *id == report_id)
.map(|(_, xml)| Arc::clone(xml))
.ok_or(SessionError::Unauthorized)
}
pub fn store_hip_preview(&self, session_id: Uuid, xml: String) -> Result<Uuid, SessionError> {
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get_mut(&session_id).ok_or(SessionError::Unauthorized)?;
if !matches!(record.status, SessionStatus::Active { .. }) {
return Err(SessionError::Unauthorized);
}
let preview_id = Uuid::new_v4();
record.hip_preview = Some((preview_id, Arc::from(xml)));
Ok(preview_id)
}
pub fn hip_preview_chunk(
&self,
session_id: Uuid,
preview_id: Uuid,
offset: usize,
) -> Result<(String, bool), SessionError> {
let sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
let (_, xml) = record
.hip_preview
.as_ref()
.filter(|(id, _)| *id == preview_id)
.ok_or(SessionError::Unauthorized)?;
if offset > xml.len() || !xml.is_char_boundary(offset) {
return Err(SessionError::Unauthorized);
}
let mut end = (offset + HIP_PREVIEW_CHUNK_BYTES).min(xml.len());
while !xml.is_char_boundary(end) {
end -= 1;
}
Ok((xml[offset..end].to_owned(), end == xml.len()))
}
pub fn store_successful_hip_report(&self, session_id: Uuid, xml: &str) -> Result<(), SessionError> {
if xml.len() > 1024 * 1024 {
return Err(SessionError::Unavailable);
}
let mut sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get_mut(&session_id).ok_or(SessionError::Unauthorized)?;
if !matches!(record.status, SessionStatus::Active { .. }) {
return Err(SessionError::Unauthorized);
}
record.last_successful_hip_report = Some(Arc::from(xml));
Ok(())
}
pub fn last_successful_hip_report(&self, session_id: Uuid) -> Result<Option<Arc<str>>, SessionError> {
let sessions = self.sessions.lock().map_err(|_| SessionError::Unavailable)?;
let record = sessions.get(&session_id).ok_or(SessionError::Unauthorized)?;
Ok(record.last_successful_hip_report.as_ref().map(Arc::clone))
}
pub fn clear_successful_hip_report(&self, session_id: Uuid) {
if let Ok(mut sessions) = self.sessions.lock()
&& let Some(record) = sessions.get_mut(&session_id)
{
record.last_successful_hip_report = None;
}
}
pub fn disconnect_if_current(&self, session_id: Uuid, generation: u64) {
let Ok(mut sessions) = self.sessions.lock() else {
return;
};
if let Some(record) = sessions.get_mut(&session_id) {
if let Some(attempt) = &record.non_tunnel {
if attempt.generation == generation {
attempt.drain.cancel();
}
}
}
if let Some(SessionRecord {
status: SessionStatus::Active {
generation: current,
@@ -561,14 +292,9 @@ impl SessionRegistry {
.lock()
.ok()
.and_then(|mut sessions| sessions.remove(&session_id))
.and_then(|record| {
if let Some(attempt) = &record.non_tunnel {
attempt.drain.cancel();
}
match record.status {
SessionStatus::Active { connection, .. } => connection,
SessionStatus::Pending { .. } => None,
}
.and_then(|record| match record.status {
SessionStatus::Active { connection, .. } => connection,
SessionStatus::Pending { .. } => None,
});
if let Some(connection) = connection {
connection.close(gpapi::service::transport::CloseReason::Unauthorized);
@@ -596,278 +322,10 @@ mod tests {
ConnectionControl::new(Uuid::new_v4(), tx).0
}
#[tokio::test]
async fn attachment_replacement_cancels_preparation_and_retains_drain_until_release() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session = credential.session_id();
let first = registry
.begin_handshake(credential.service_instance_id(), session, "fixture")
.unwrap();
let (tx, _rx) = mpsc::channel(4);
let first_control = ConnectionControl::new(Uuid::new_v4(), tx).0;
let old_id = first_control.connection_id();
registry.commit_attach(&first, first_control).unwrap();
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
let reservation = registry
.reserve_connection(session, 1, true, || lifecycle.reserve_connect())
.unwrap();
let drain = reservation.drain();
let cancel = reservation.cancellation();
let next = registry
.begin_handshake(credential.service_instance_id(), session, "fixture")
.unwrap();
let (tx, _next_rx) = mpsc::channel(4);
registry
.commit_attach(&next, ConnectionControl::new(Uuid::new_v4(), tx).0)
.unwrap();
assert!(cancel.is_cancelled());
assert!(!drain.is_complete());
assert!(
registry
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
.is_err()
);
assert!(matches!(
registry.commit_connection(session, 1, true, || panic!("stale start committed")),
ServiceResult::Rejected(_)
));
drop(reservation);
drain.wait().await;
let next_reservation = registry
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
.unwrap();
assert!(
registry
.stop_non_tunnel_attachment(session, 2, old_id)
.unwrap()
.is_none()
);
assert!(!next_reservation.cancellation().is_cancelled());
registry.disconnect_if_current(session, 1);
assert!(!next_reservation.cancellation().is_cancelled());
registry.disconnect_if_current(session, 2);
assert!(next_reservation.cancellation().is_cancelled());
}
#[tokio::test]
async fn scoped_stop_closes_attachment_to_delayed_starts_without_receipt_history() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session = credential.session_id();
let permit = registry
.begin_handshake(credential.service_instance_id(), session, "fixture")
.unwrap();
let (tx, _rx) = mpsc::channel(4);
let connection = ConnectionControl::new(Uuid::new_v4(), tx).0;
let id = connection.connection_id();
registry.commit_attach(&permit, connection).unwrap();
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
let reservation = registry
.reserve_connection(session, 1, true, || lifecycle.reserve_connect())
.unwrap();
let drain = registry.stop_non_tunnel_attachment(session, 1, id).unwrap().unwrap();
assert!(reservation.cancellation().is_cancelled());
assert!(matches!(
registry.commit_connection(session, 1, true, || panic!("closing start committed")),
ServiceResult::Rejected(_)
));
assert!(!drain.is_complete());
drop(reservation);
drain.wait().await;
assert!(
registry
.reserve_connection(session, 1, true, || panic!("closed attachment reserved"))
.is_err()
);
assert!(
registry
.reserve_connection(session, 1, false, || lifecycle.reserve_connect())
.is_ok()
);
}
#[tokio::test]
async fn tunnel_reservation_survives_attachment_loss_but_non_tunnel_revocation_cancels() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session = credential.session_id();
let permit = registry
.begin_handshake(credential.service_instance_id(), session, "fixture")
.unwrap();
let (tx, _rx) = mpsc::channel(4);
registry
.commit_attach(&permit, ConnectionControl::new(Uuid::new_v4(), tx).0)
.unwrap();
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
let tunnel = registry
.reserve_connection(session, 1, false, || lifecycle.reserve_connect())
.unwrap();
registry.disconnect_if_current(session, 1);
assert!(!tunnel.cancellation().is_cancelled());
assert_eq!(
registry.commit_connection(session, 1, false, || ServiceResult::Accepted),
ServiceResult::Accepted
);
drop(tunnel);
let permit = registry
.begin_handshake(credential.service_instance_id(), session, "fixture")
.unwrap();
let (tx, _next_rx) = mpsc::channel(4);
registry
.commit_attach(&permit, ConnectionControl::new(Uuid::new_v4(), tx).0)
.unwrap();
let session_work = registry
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
.unwrap();
registry.revoke(session);
assert!(session_work.cancellation().is_cancelled());
assert!(!session_work.drain().is_complete());
}
#[test]
fn credential_retains_verified_desktop_user_across_reconnect() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4", Some(1000)).unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
assert_eq!(first.desktop_uid, Some(1000));
registry.commit_attach(&first, control()).unwrap();
let reconnect = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
assert_eq!(reconnect.desktop_uid, Some(1000));
}
#[test]
fn edited_hip_report_is_session_bound_and_replaced_without_affecting_pinned_content() {
fn upload(registry: &SessionRegistry, session_id: Uuid, xml: &str) -> Uuid {
let mut upload_id = None;
let mut offset = 0;
while offset < xml.len() {
let mut end = (offset + 8 * 1024).min(xml.len());
while !xml.is_char_boundary(end) {
end -= 1;
}
let complete = end == xml.len();
match registry
.append_edited_hip_report_chunk(session_id, upload_id, offset, xml[offset..end].into(), complete)
.unwrap()
{
HipUploadResult::Progress(id) => upload_id = Some(id),
HipUploadResult::Stored(id) => return id,
}
offset = end;
}
panic!("upload did not complete")
}
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let first_credential = registry.issue("2.6.4", Some(1000)).unwrap();
let second_credential = registry.issue("2.6.4", Some(1001)).unwrap();
for credential in [&first_credential, &second_credential] {
let permit = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
registry.commit_attach(&permit, control()).unwrap();
}
let valid = gphip::generate_report(&gphip::ReportInput {
profile: gpapi::os_profile::OsProfile::builder(gpapi::os_profile::ClientOs::Linux).build(),
context: gphip::ReportContext::Preview,
})
.unwrap();
let first_id = upload(&registry, first_credential.session_id(), &valid);
let pinned = registry
.edited_hip_report(first_credential.session_id(), first_id)
.unwrap();
assert!(matches!(
registry.edited_hip_report(second_credential.session_id(), first_id),
Err(SessionError::Unauthorized)
));
let second_id = upload(&registry, first_credential.session_id(), &valid);
assert!(matches!(
registry.edited_hip_report(first_credential.session_id(), first_id),
Err(SessionError::Unauthorized)
));
assert_eq!(
&*registry
.edited_hip_report(first_credential.session_id(), second_id)
.unwrap(),
valid
);
assert_eq!(&*pinned, valid);
registry.revoke(first_credential.session_id());
assert!(matches!(
registry.edited_hip_report(first_credential.session_id(), second_id),
Err(SessionError::Unauthorized)
));
}
#[test]
fn submitted_report_changes_only_after_success_callback_and_is_session_bound() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4", Some(1000)).unwrap();
let permit = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
registry.commit_attach(&permit, control()).unwrap();
assert!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.is_none()
);
registry
.store_successful_hip_report(credential.session_id(), "first")
.unwrap();
assert_eq!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.as_deref(),
Some("first")
);
let preview_id = registry
.store_hip_preview(credential.session_id(), "é".repeat(8193))
.unwrap();
let (first_chunk, complete) = registry
.hip_preview_chunk(credential.session_id(), preview_id, 0)
.unwrap();
assert!(!complete);
assert!(first_chunk.len() <= HIP_PREVIEW_CHUNK_BYTES);
assert!(
registry
.hip_preview_chunk(credential.session_id(), preview_id, 1)
.is_err()
);
assert_eq!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.as_deref(),
Some("first")
);
registry.clear_successful_hip_report(credential.session_id());
assert!(
registry
.last_successful_hip_report(credential.session_id())
.unwrap()
.is_none()
);
}
#[test]
fn reconnect_uses_generation_compare_and_swap() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4", None).unwrap();
let credential = registry.issue("2.6.4").unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
@@ -888,7 +346,7 @@ mod tests {
#[test]
fn failed_initial_handshake_only_revokes_its_own_reservation() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4", None).unwrap();
let credential = registry.issue("2.6.4").unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
@@ -902,7 +360,7 @@ mod tests {
#[test]
fn failed_reconnect_keeps_active_connection_authoritative() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue("2.6.4", None).unwrap();
let credential = registry.issue("2.6.4").unwrap();
let first = registry
.begin_handshake(credential.service_instance_id(), credential.session_id(), "2.6.4")
.unwrap();
File diff suppressed because it is too large. Load diff
-192
View File
@@ -1,192 +0,0 @@
use std::{sync::Arc, time::Duration};
use anyhow::Context;
use gpapi::process::collection::CollectionControl;
use gpapi::session::{
GatewaySessionSummary, MaintenanceState, SessionEndReason,
non_tunnel::{SessionCallbacks, SessionExit, maintain_non_tunnel_sessions},
};
use log::warn;
use tokio::sync::{mpsc, watch};
use tokio_util::sync::CancellationToken;
use super::{
LifecycleEvent,
runtime::{AttemptInput, stop_for_revoked_approval},
};
/// Borrow the accepted ledger. The outer attempt owner retains identity/source
/// resources and joins this runtime before draining the remaining members.
pub(super) async fn run(
input: &mut AttemptInput,
source: Arc<openconnect::HipSource>,
approval: &crate::hip_source::HipApproval,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) -> anyhow::Result<SessionExit> {
let request = &input.connection.request;
let args = request.args();
let resources = &input.connection.resources;
let sessions = &mut input.connection.sessions;
let network = resources
.network
.as_ref()
.context("Physical network context is missing")?;
let posture_enabled =
request.plan().policy().collect_hip_data() && !matches!(args.hip_source(), gpapi::hip::HipSource::Disabled);
let profile = resources.profile.clone();
let initial = sessions
.members()
.iter()
.map(|session| GatewaySessionSummary {
gateway: session.gateway.clone(),
mode: gpapi::session::SessionMode::NonTunnel,
client_ip: session.addresses.ipv4.map(|ip| ip.to_string()),
client_ipv6: session.addresses.ipv6.map(|ip| ip.to_string()),
maintenance: MaintenanceState::Authenticated,
})
.collect::<Vec<_>>();
let (status, mut changed) = watch::channel(initial);
let registry = input.registry.clone();
let session_id = input.session_id;
let validation_network = network.clone();
let validation_detection = request.plan().internal_detection().cloned();
let callbacks = SessionCallbacks {
validate_network: Arc::new(move |cancel| {
let network = validation_network.clone();
let detection = validation_detection.clone();
Box::pin(async move { network.validate_internal(detection.as_ref(), &cancel).await })
}),
produce_report: Arc::new(move |request, control| {
control.check()?;
let context = gphip::ReportContext::Connected {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
};
if !posture_enabled {
return gphip::generate_identity_report(&gphip::ReportInput {
profile: profile.clone(),
context,
})
.map_err(std::io::Error::other);
}
source.collect(
&openconnect::HipRequest {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
client_version: profile.client_version().into(),
client_os: profile.client_os().as_str().into(),
os_version: profile.os_version().into(),
host_id: Some(profile.host_id().into()),
local_hostname: Some(profile.computer().into()),
},
&|| control.check(),
)
}),
report_submitted: Arc::new(move |_, xml| {
if let Some(session_id) = session_id {
if let Err(error) = registry.store_successful_hip_report(session_id, xml) {
warn!("Could not retain submitted HIP report: {error}");
}
}
}),
status_changed: Arc::new(move |summary| {
status.send_modify(|members| {
if let Some(member) = members
.iter_mut()
.find(|member| member.gateway.server() == summary.gateway.server())
{
*member = summary;
}
});
}),
};
let monitor_cancel = cancellation.child_token();
let monitor_token = monitor_cancel.clone();
let network = network.clone();
let detection = request.plan().internal_detection().cloned();
let (network_changed, network_signal) = tokio::sync::oneshot::channel();
let monitor = tokio::spawn(async move {
match network.wait_for_change(detection, monitor_token).await {
Ok(false) => {}
Ok(true) => {
let _ = network_changed.send(SessionEndReason::NetworkChanged);
}
Err(error) => {
warn!("Physical network inspection failed: {error}");
let _ = network_changed.send(SessionEndReason::NetworkChanged);
}
}
});
let mut approval_revoked = false;
let result = {
let lifecycle_cancel = cancellation.clone();
let maintenance = maintain_non_tunnel_sessions(
sessions,
request.plan().policy(),
callbacks,
lifecycle_cancel,
async move { network_signal.await.unwrap_or(SessionEndReason::NetworkChanged) },
);
tokio::pin!(maintenance);
let mut approval_poll = tokio::time::interval(Duration::from_secs(1));
let mut publish = true;
let result = loop {
if publish && !cancellation.is_cancelled() {
let members = changed.borrow_and_update().clone();
let _ = events
.send(LifecycleEvent::MembersChanged {
attempt: input.attempt,
members,
failures: request.plan().failures().to_vec(),
})
.await;
publish = false;
}
tokio::select! {
biased;
result = &mut maintenance => break result,
_ = approval_poll.tick() => if !approval.approval_is_valid() {
approval_revoked = true;
stop_for_revoked_approval(&input.lifecycle, &cancellation);
},
result = changed.changed() => { if result.is_ok() { publish = true; } },
}
};
// Maintenance can invalidate every member and finish in the same poll.
// Forward that last snapshot before monitor/remote cleanup, even when the
// completed maintenance branch won over the watch notification.
if !cancellation.is_cancelled() {
let members = changed.borrow_and_update().clone();
let _ = events
.send(LifecycleEvent::MembersChanged {
attempt: input.attempt,
members,
failures: request.plan().failures().to_vec(),
})
.await;
}
result
};
monitor_cancel.cancel();
monitor.await.context("Network monitor worker failed")?;
if approval_revoked {
let _ = events
.send(LifecycleEvent::Failed {
attempt: input.attempt,
reason: "HIP script approval was revoked".into(),
})
.await;
}
// resources and approval remain owned until maintenance/logout and monitor
// inspection are drained. Deliberate disconnect wins throughout cleanup.
if cancellation.is_cancelled() {
Ok(SessionExit::Disconnected)
} else {
result
}
}
@@ -1,213 +0,0 @@
use std::{
io::{Read, Write},
sync::Arc,
time::Duration,
};
use gpapi::{
gateway::Gateway,
gp_params::GpParams,
service::{
transport::ServiceResult,
vpn_state::{ConnectInfo, VpnState},
},
session::{ClientAddresses, GatewayAuthentication, GatewaySession, GatewaySessions, transport::GatewayTransport},
};
use openssl::{
asn1::Asn1Time,
hash::MessageDigest,
pkey::PKey,
rsa::Rsa,
ssl::{SslAcceptor, SslMethod},
x509::{X509, X509NameBuilder},
};
use tokio::sync::{oneshot, watch};
use super::{LifecycleEvent, PreparedConnection, VpnTask, test_connect_request};
fn tls_acceptor() -> SslAcceptor {
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
let mut name = X509NameBuilder::new().unwrap();
name.append_entry_by_text("CN", "localhost").unwrap();
let name = name.build();
let mut cert = X509::builder().unwrap();
cert.set_version(2).unwrap();
cert.set_subject_name(&name).unwrap();
cert.set_issuer_name(&name).unwrap();
cert.set_pubkey(&key).unwrap();
cert.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
cert.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
cert.sign(&key, MessageDigest::sha256()).unwrap();
let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
acceptor.set_private_key(&key).unwrap();
acceptor.set_certificate(&cert.build()).unwrap();
acceptor.check_private_key().unwrap();
acceptor.build()
}
/// Exercise the real HTTPS logout transport without any production network,
/// host collectors, or user identity files. The response gate proves admission
/// stays owned until the server request finishes.
#[tokio::test]
async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let endpoint = listener.local_addr().unwrap();
let server_name = format!("https://{endpoint}");
let mut gateway = serde_json::to_value(Gateway::new("fixture".into(), server_name.clone())).unwrap();
gateway["kind"] = serde_json::json!("internal");
let gateway: Gateway = serde_json::from_value(gateway).unwrap();
let registry = Arc::new(crate::session_registry::SessionRegistry::new(uuid::Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session_id = credential.session_id();
let permit = registry
.begin_handshake(credential.service_instance_id(), session_id, "fixture")
.unwrap();
let (tx, _rx) = tokio::sync::mpsc::channel(4);
let control = crate::ws_connection::ConnectionControl::new(uuid::Uuid::new_v4(), tx).0;
let connection_id = control.connection_id();
registry.commit_attach(&permit, control).unwrap();
let fixture = test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![]));
let mut member = fixture.plan().members()[0].clone();
member.authentication =
GatewayAuthentication::new("authcookie=fixture&user=fixture".into(), "internal".into()).unwrap();
let plan = gpapi::session::ConnectionPlan::new(vec![member], vec![], fixture.plan().policy()).unwrap();
let request = gpapi::service::request::ConnectRequest::new(fixture.info().clone(), plan);
let mut prepared = PreparedConnection::lifecycle_fixture(request);
let mut params = GpParams::builder(prepared.resources.profile.clone());
params.ignore_tls_errors(true);
prepared.sessions = GatewaySessions::new(vec![GatewaySession {
gateway,
transport: GatewayTransport::new(
&server_name,
prepared.request.plan().members()[0].authentication.clone(),
&params.build(),
prepared.request.plan().members()[0].binding.as_ref(),
)
.unwrap(),
addresses: ClientAddresses::default(),
}]);
let acceptor = tls_acceptor();
let (arrived, arrival) = oneshot::channel();
let (release, response_gate) = oneshot::channel();
let server = tokio::spawn(async move {
let (socket, _) = tokio::time::timeout(Duration::from_secs(3), listener.accept())
.await
.unwrap()
.unwrap();
let socket = socket.into_std().unwrap();
socket.set_nonblocking(false).unwrap();
socket.set_read_timeout(Some(Duration::from_secs(3))).unwrap();
socket.set_write_timeout(Some(Duration::from_secs(3))).unwrap();
let request = tokio::task::spawn_blocking(move || {
let mut stream = acceptor.accept(socket).unwrap();
let mut bytes = Vec::new();
let (headers_end, body_len) = loop {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
if let Some(position) = bytes.windows(4).position(|part| part == b"\r\n\r\n") {
let headers = std::str::from_utf8(&bytes[..position]).unwrap();
let length = headers
.lines()
.find_map(|line| {
let (key, value) = line.split_once(':')?;
key
.eq_ignore_ascii_case("content-length")
.then(|| value.trim().parse::<usize>().unwrap())
})
.unwrap();
break (position + 4, length);
}
};
while bytes.len() < headers_end + body_len {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
}
arrived.send(()).unwrap();
response_gate.blocking_recv().unwrap();
let body = "<response status=\"success\"/>";
write!(
stream,
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
.unwrap();
stream.flush().unwrap();
String::from_utf8(bytes).unwrap()
})
.await
.unwrap();
// A single accepted authentication must produce a single logout.
assert!(
tokio::time::timeout(Duration::from_millis(100), listener.accept())
.await
.is_err()
);
request
});
let (state, state_rx) = watch::channel(VpnState::Disconnected);
let (mut task, lifecycle) = VpnTask::new(state, false, registry.clone());
let reservation = registry
.reserve_connection(session_id, 1, true, || lifecycle.reserve_connect())
.unwrap();
assert_eq!(
registry.commit_connection(session_id, 1, true, || reservation.commit(
prepared,
None,
None,
Some(session_id)
)),
ServiceResult::Accepted
);
let drain = registry
.stop_non_tunnel_attachment(session_id, 1, connection_id)
.unwrap()
.unwrap();
let drain_waiter = tokio::spawn(async move {
drain.wait().await;
});
let start = task.events.recv().await.unwrap();
assert!(matches!(&start, LifecycleEvent::Start { .. }));
task.handle_event(start).await;
tokio::time::timeout(Duration::from_secs(3), arrival)
.await
.unwrap()
.unwrap();
assert!(lifecycle.has_attempt(0));
assert!(!drain_waiter.is_finished());
assert!(lifecycle.reserve_connect().is_err());
assert!(!task.active.as_ref().unwrap().task.is_finished());
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
release.send(()).unwrap();
while task.active.is_some() {
let event = tokio::time::timeout(Duration::from_secs(3), task.events.recv())
.await
.unwrap()
.unwrap();
task.handle_event(event).await;
}
assert!(!lifecycle.has_attempt(0));
drain_waiter.await.unwrap();
assert!(lifecycle.reserve_connect().is_ok());
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
let request = server.await.unwrap();
assert!(request.starts_with("POST /ssl-vpn/logout.esp "));
let form = request.split_once("\r\n\r\n").unwrap().1;
let fields = url_form(form);
assert_eq!(fields.get("user").map(String::as_str), Some("fixture"));
assert_eq!(fields.get("computer").map(String::as_str), Some("fixture"));
assert_eq!(fields.get("clientos").map(String::as_str), Some("Linux"));
}
fn url_form(form: &str) -> std::collections::HashMap<String, String> {
form
.split('&')
.map(|field| {
let (key, value) = field.split_once('=').unwrap();
(key.to_owned(), value.to_owned())
})
.collect()
}
-232
View File
@@ -1,232 +0,0 @@
use std::{sync::Arc, time::Duration};
use anyhow::Context;
use gpapi::{
gp_params::GpParams,
os_profile::OsProfile,
process::collection::{CollectionBudget, CollectionControl},
service::request::ConnectRequest,
session::{GatewaySession, GatewaySessions, network::PhysicalNetwork, transport::GatewayTransport},
};
use tokio_util::sync::CancellationToken;
pub(crate) struct PreparedConnection {
pub(super) request: ConnectRequest,
pub(super) resources: Arc<ConnectionResources>,
pub(super) sessions: GatewaySessions,
}
pub(super) struct ConnectionResources {
pub profile: OsProfile,
pub identity: Option<gpapi::utils::request::ClientIdentity>,
pub identity_files: Option<gpapi::utils::request::ClientIdentityFiles>,
pub network: Option<PhysicalNetwork>,
}
/// Preparation sends no authenticated gateway requests. Rejection leaves the
/// authentication owner responsible for logout; only queued admission transfers
/// the complete ledger and its retained identity resources to the service.
pub(crate) async fn prepare_connection(
request: ConnectRequest,
brokered_macos: bool,
cancellation: CancellationToken,
) -> anyhow::Result<PreparedConnection> {
let args = request.args();
let non_tunnel = request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel);
anyhow::ensure!(
non_tunnel || request.plan().members().len() == 1,
"Only one selected tunnel gateway can execute"
);
for member in request.plan().members() {
if non_tunnel {
let binding = member.binding.as_ref().context("Internal gateway binding is missing")?;
anyhow::ensure!(
!args.disable_ipv6() || (binding.endpoint().is_ipv4() && binding.addresses().ipv6.is_none()),
"IPv6 gateway transport or identity is disabled"
);
}
}
let setup_request = request.clone();
let setup_cancel = cancellation.clone();
let resources = tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(Duration::from_secs(60));
let check = || {
if setup_cancel.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"Connection preparation cancelled",
));
}
budget.check()
};
check()?;
let args = setup_request.args();
let identity = super::prepare_identity(args, brokered_macos || non_tunnel)?;
let directory = brokered_macos.then(|| std::path::Path::new("/var/run/com.yuezk.gpgui"));
let identity_files = identity
.as_ref()
.map(|identity| identity.write_files(directory))
.transpose()?;
let host = args.host_identity().context("Authenticated host identity is missing")?;
let profile = crate::hip_source::profile(
host,
args.os().context("Authenticated client OS is missing")?,
args.client_version(),
args.os_version(),
args.host_id(),
args.local_hostname(),
&check,
)?;
let network = if non_tunnel {
Some(PhysicalNetwork::capture(&check)?)
} else {
None
};
check()?;
Ok::<_, anyhow::Error>(Arc::new(ConnectionResources {
profile,
identity,
identity_files,
network,
}))
})
.await??;
let args = request.args();
let mut builder = GpParams::builder(resources.profile.clone());
builder
.ignore_tls_errors(args.ignore_tls_errors())
.client_identity(resources.identity.clone());
let params = builder.build();
let mut sessions = Vec::new();
for member in request.plan().members() {
let binding = if non_tunnel {
Some(member.binding.as_ref().context("Internal gateway binding is missing")?)
} else {
None
};
if let Some(network) = &resources.network {
network
.validate_internal_binding(
binding.context("Internal gateway binding is missing")?,
request.plan().internal_detection(),
&cancellation,
)
.await?;
}
let transport = GatewayTransport::new(member.gateway.server(), member.authentication.clone(), &params, binding)?;
sessions.push(GatewaySession {
gateway: member.gateway.clone(),
transport,
addresses: binding.map(|binding| binding.addresses()).unwrap_or_default(),
});
}
if let Some(network) = &resources.network {
network.ensure_current(&cancellation).await?;
}
Ok(PreparedConnection {
request,
resources,
sessions: GatewaySessions::new(sessions),
})
}
#[cfg(test)]
impl PreparedConnection {
/// Lifecycle-only fixtures own no issued server sessions. Protocol ownership
/// checks use actual gateway transports rather than this actor-state fixture.
pub(crate) fn lifecycle_fixture(request: ConnectRequest) -> Self {
let profile = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
))
.build();
Self {
request,
resources: Arc::new(ConnectionResources {
profile,
identity: None,
identity_files: None,
network: None,
}),
sessions: GatewaySessions::new(vec![]),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::{gateway::Gateway, service::vpn_state::ConnectInfo};
#[tokio::test]
async fn brokered_macos_and_non_tunnel_identity_reject_path_handoff() {
for (brokered_macos, non_tunnel) in [(true, false), (false, true), (true, true)] {
let gateway = Gateway::new("fixture".into(), "gateway.example.com".into());
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_certificate(Some("/identity.pem".into()));
let mut wire = serde_json::to_value(request).unwrap();
if non_tunnel {
wire["plan"]["members"][0]["gateway"]["kind"] = serde_json::json!("internal");
wire["plan"]["members"][0]["authentication"]["connection_type"] = serde_json::json!("internal");
}
let request = serde_json::from_value(wire).unwrap();
let error = prepare_connection(request, brokered_macos, CancellationToken::new())
.await
.err()
.unwrap();
assert_eq!(error.to_string(), "Client identity must be a protected snapshot");
}
}
#[tokio::test]
async fn disabled_ipv6_rejects_ipv6_report_identity_before_setup() {
let gateway = Gateway::new("fixture".into(), "gateway.example.com".into());
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_disable_ipv6(true);
let mut wire = serde_json::to_value(request).unwrap();
wire["plan"]["members"][0]["gateway"]["kind"] = serde_json::json!("internal");
wire["plan"]["members"][0]["authentication"]["connection_type"] = serde_json::json!("internal");
wire["plan"]["members"][0]["binding"]["addresses"]["ipv6"] = serde_json::json!("2001:db8::5");
let request: ConnectRequest = serde_json::from_value(wire).unwrap();
// The fixture has no host identity or usable physical interface. Policy
// rejection must happen before those collectors or transport setup run.
let error = prepare_connection(request, false, CancellationToken::new())
.await
.err()
.unwrap();
assert_eq!(error.to_string(), "IPv6 gateway transport or identity is disabled");
}
#[tokio::test]
async fn ordinary_tunnel_preparation_needs_no_physical_binding_or_resolver() {
let gateway = Gateway::new("fixture".into(), "does-not-resolve.invalid".into());
let profile = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
))
.build();
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_os_profile(&profile)
.with_disable_ipv6(true);
let mut wire = serde_json::to_value(request).unwrap();
wire["plan"]["members"][0]["binding"] = serde_json::Value::Null;
let request: ConnectRequest = serde_json::from_value(wire).unwrap();
let prepared = prepare_connection(request, false, CancellationToken::new())
.await
.unwrap();
assert!(prepared.resources.network.is_none());
assert_eq!(prepared.sessions.members().len(), 1);
assert!(prepared.sessions.members()[0].addresses.ipv4.is_none());
assert!(prepared.sessions.members()[0].addresses.ipv6.is_none());
}
}
-302
View File
@@ -1,302 +0,0 @@
use std::{sync::Arc, time::Duration};
use anyhow::{Context, ensure};
use gpapi::{
process::collection::{CollectionBudget, CollectionControl},
service::request::ConnectRequest,
session::SessionMode,
};
use log::warn;
use openconnect::Vpn;
use tokio::{sync::mpsc, task::JoinHandle};
use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use super::{LifecycleEvent, LifecycleHandle, PreparedConnection, preparation::ConnectionResources};
pub(super) struct AttemptInput {
pub attempt: u64,
pub connection: PreparedConnection,
pub desktop_uid: Option<u32>,
pub edited_report: Option<Arc<str>>,
pub session_id: Option<Uuid>,
pub brokered_macos: bool,
pub registry: Arc<crate::session_registry::SessionRegistry>,
pub lifecycle: LifecycleHandle,
}
struct TunnelInput {
request: ConnectRequest,
resources: Arc<ConnectionResources>,
source: Arc<openconnect::HipSource>,
session_id: Option<Uuid>,
registry: Arc<crate::session_registry::SessionRegistry>,
}
struct PreparedTunnel {
vpn: Arc<Vpn>,
}
/// The accepted attempt owns cleanup through fallible setup. Non-tunnel workers
/// borrow that ledger; a native tunnel takes its cleanup ownership when started.
/// Cancellation joins execution before draining any remaining issued sessions.
pub(super) fn spawn(
mut input: AttemptInput,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) -> JoinHandle<()> {
tokio::spawn(async move {
let attempt = input.attempt;
let non_tunnel = input
.connection
.request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == SessionMode::NonTunnel);
let mut failure = None;
let mut approval = None;
if !cancellation.is_cancelled() {
let request = input.connection.request.clone();
let resources = input.connection.resources.clone();
let desktop_uid = input.desktop_uid;
let brokered = input.brokered_macos;
let edited = input.edited_report.clone();
let setup_cancel = cancellation.clone();
let execution = tokio::task::spawn_blocking(move || {
prepare_execution(request, resources, desktop_uid, brokered, edited, &setup_cancel)
})
.await;
match execution {
Ok(Ok(execution)) => {
let (source, guard) = execution.into_parts();
approval = Some(guard);
let source = Arc::new(source);
let guard = approval.as_ref().expect("execution approval is retained");
if input
.connection
.request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == SessionMode::NonTunnel)
{
match super::non_tunnel::run(&mut input, source, guard, cancellation.clone(), events.clone()).await {
Ok(gpapi::session::non_tunnel::SessionExit::Disconnected) => {}
Ok(gpapi::session::non_tunnel::SessionExit::Failed(reason)) => {
let message = match reason {
gpapi::session::SessionEndReason::InvalidCookie => {
"Internal gateway authentication expired; connect again"
}
gpapi::session::SessionEndReason::NetworkChanged => {
"Physical network changed or could not be verified; connect again"
}
gpapi::session::SessionEndReason::AllMembersFailed => {
"All internal gateway sessions failed; connect again"
}
gpapi::session::SessionEndReason::AuthorizationRevoked => "HIP execution authorization was revoked",
};
failure = Some(message.into());
}
Err(error) => {
warn!("Non-tunnel maintenance failed: {error:#}");
failure = Some("Internal session maintenance failed".into());
}
}
} else {
let tunnel_input = TunnelInput {
request: input.connection.request.clone(),
resources: input.connection.resources.clone(),
source,
session_id: input.session_id,
registry: input.registry.clone(),
};
let setup_cancel = cancellation.clone();
let prepared = tokio::task::spawn_blocking(move || prepare_tunnel(tunnel_input, &setup_cancel)).await;
match prepared {
Ok(Ok(prepared)) => {
run_tunnel(
attempt,
&prepared,
guard,
&input.lifecycle,
&mut input.connection.sessions,
cancellation.clone(),
events.clone(),
)
.await
}
Ok(Err(error)) => warn!("Failed to prepare tunnel: {error:#}"),
Err(error) => warn!("Tunnel setup worker failed: {error}"),
}
}
}
Ok(Err(error)) => {
warn!("Failed to prepare HIP execution: {error:#}");
failure = Some("HIP execution could not be prepared".into());
}
Err(error) => {
warn!("HIP setup worker failed: {error}");
failure = Some("HIP setup worker failed".into());
}
}
}
input.connection.sessions.logout().await;
// Identity and approval remain alive through worker drain and logout. Ended
// only releases admission after the actor also joins this task.
drop(approval);
if non_tunnel && !cancellation.is_cancelled() {
if let Some(reason) = failure {
let _ = events.send(LifecycleEvent::Failed { attempt, reason }).await;
}
}
let _ = events.send(LifecycleEvent::Ended { attempt }).await;
})
}
fn prepare_execution(
request: ConnectRequest,
resources: Arc<ConnectionResources>,
desktop_uid: Option<u32>,
brokered: bool,
edited: Option<Arc<str>>,
cancellation: &CancellationToken,
) -> anyhow::Result<crate::hip_source::HipExecution> {
let budget = CollectionBudget::new(Duration::from_secs(60));
let check = || {
if cancellation.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"HIP setup cancelled",
));
}
budget.check()
};
check()?;
let args = request.args();
let pure_non_tunnel = request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == SessionMode::NonTunnel);
let disabled = pure_non_tunnel && !request.plan().policy().collect_hip_data();
let source = if disabled {
&gpapi::hip::HipSource::Disabled
} else {
args.hip_source()
};
let execution = crate::hip_source::resolve(source, desktop_uid, brokered, edited, Some(resources.profile.clone()))?;
check()?;
Ok(execution)
}
fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyhow::Result<PreparedTunnel> {
let args = input.request.args();
let budget = CollectionBudget::new(Duration::from_secs(60));
let check = || {
if cancellation.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"Tunnel setup cancelled",
));
}
budget.check()
};
check()?;
ensure!(
input.request.plan().members().len() == 1
&& input.request.plan().members()[0].authentication.mode() == SessionMode::Tunnel,
"Tunnel execution requires one selected tunnel gateway"
);
let member = &input.request.plan().members()[0];
let identity_files = &input.resources.identity_files;
let vpn = Arc::new(
crate::vpn_script::builder(member.gateway.server(), member.authentication.cookie(), args)?
.user_agent(args.user_agent())
.os(args.openconnect_os())
.os_version(args.os_version())
.client_version(args.client_version())
.host_id(args.host_id())
.certificate(identity_files.as_ref().map(|files| files.certificate().to_owned()))
.sslkey(identity_files.as_ref().and_then(|files| files.key()).map(str::to_owned))
.key_password(
input
.resources
.identity
.as_ref()
.and_then(|identity| identity.key_password())
.map(str::to_owned),
)
.hip_source(input.source)
.reconnect_timeout(args.reconnect_timeout())
.mtu(args.mtu())
.disable_ipv6(args.disable_ipv6())
.no_dtls(args.no_dtls())
.local_hostname(args.local_hostname())
.dpd_interval(args.force_dpd())
.no_xmlpost(args.no_xmlpost())
.build()
.context("Failed to create tunnel worker")?,
);
check()?;
if let Some(session_id) = input.session_id {
let registry = input.registry;
vpn.set_hip_report_callback(move |xml| {
if let Err(error) = registry.store_successful_hip_report(session_id, xml) {
warn!("Could not retain submitted HIP report: {error}");
}
});
}
Ok(PreparedTunnel { vpn })
}
async fn run_tunnel(
attempt: u64,
prepared: &PreparedTunnel,
approval: &crate::hip_source::HipApproval,
lifecycle: &LifecycleHandle,
sessions: &mut gpapi::session::GatewaySessions,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) {
if cancellation.is_cancelled() {
return;
}
let vpn = prepared.vpn.clone();
// The native tunnel keeps its reconnect endpoint and cookie current and owns
// normal logout. The ledger remains responsible only before native execution.
// Service admission permits exactly one tunnel member.
std::mem::take(sessions).relinquish();
let worker = tokio::task::spawn_blocking(move || {
vpn.connect(move |session| {
let _ = events.blocking_send(LifecycleEvent::Established { attempt, session });
})
});
tokio::pin!(worker);
let mut approval_poll = tokio::time::interval(Duration::from_secs(1));
let result = loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => { prepared.vpn.disconnect(); break (&mut worker).await; },
result = &mut worker => break result,
_ = approval_poll.tick() => if !approval.approval_is_valid() {
stop_for_revoked_approval(lifecycle, &cancellation);
prepared.vpn.disconnect();
break (&mut worker).await;
},
}
};
match result {
Ok(0 | -4) => {}
Ok(code) => warn!("Tunnel worker exited with status {code}"),
Err(error) => warn!("Tunnel worker failed: {error}"),
}
}
pub(super) fn stop_for_revoked_approval(lifecycle: &LifecycleHandle, cancellation: &CancellationToken) {
let result = lifecycle.request_disconnect();
if !matches!(result, gpapi::service::transport::ServiceResult::Accepted) {
warn!("Could not enqueue approval revocation stop: {result:?}");
}
cancellation.cancel();
}
+9 -191
View File
@@ -4,9 +4,8 @@ use axum::extract::ws::{CloseFrame, Message, Utf8Bytes, WebSocket};
use futures::StreamExt;
use gpapi::service::transport::{
ClientMessage, ClientPrelude, CloseReason, HandshakeRejection, NoiseResponder, NoiseTransport, ServerMessage,
ServerPrelude, ServiceErrorCode, ServiceResult,
ServerPrelude, ServiceResult,
};
use gpapi::{hip::HipSource, service::request::WsRequest};
use log::{info, warn};
use tokio::sync::{mpsc, watch};
use tokio::time::Instant;
@@ -58,11 +57,11 @@ impl ConnectionControl {
}
pub fn is_closed(&self) -> bool {
self.tx.is_closed() || self.close_tx.borrow().is_some()
self.tx.is_closed()
}
pub fn close(&self, reason: CloseReason) {
self.close_tx.send_replace(Some(reason));
let _ = self.close_tx.send(Some(reason));
}
pub async fn send_reply(&self, id: Uuid, result: ServiceResult) {
@@ -149,7 +148,6 @@ impl WsConnection {
&ctx,
&control,
permit.session_id,
permit.desktop_uid,
generation,
&mut pending_requests,
).await.is_err() {
@@ -187,10 +185,6 @@ impl WsConnection {
ctx
.remove_connection(control.connection_id(), permit.session_id, generation)
.await;
ctx
.hip_previews
.cancel_connection(permit.session_id, control.connection_id())
.await;
info!("GUI connection {} closed", control.connection_id());
}
}
@@ -221,17 +215,6 @@ async fn establish(
.await?;
return Err(CloseReason::VersionMismatch);
}
if prelude.hip_protocol_version != gpapi::service::transport::HIP_PROTOCOL_VERSION {
send_server_prelude(
socket,
ServerPrelude::Rejected(HandshakeRejection::HipProtocolMismatch {
client: prelude.hip_protocol_version,
service: gpapi::service::transport::HIP_PROTOCOL_VERSION,
}),
)
.await?;
return Err(CloseReason::VersionMismatch);
}
let permit = match ctx.registry().begin_handshake(
prelude.service_instance_id,
@@ -325,7 +308,6 @@ async fn handle_client_message(
ctx: &Arc<WsServerContext>,
control: &ConnectionControl,
session_id: Uuid,
desktop_uid: Option<u32>,
generation: u64,
pending_requests: &mut HashSet<Uuid>,
) -> Result<(), ()> {
@@ -341,175 +323,10 @@ async fn handle_client_message(
return Err(());
}
if let WsRequest::StoreEditedHipReportChunk(report) = request {
let upload_id = report.upload_id.as_deref().and_then(|id| Uuid::parse_str(id).ok());
let result = if report.upload_id.is_some() && upload_id.is_none() {
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP upload ID")
} else {
match ctx.registry().append_edited_hip_report_chunk(
session_id,
upload_id,
report.offset,
report.xml,
report.complete,
) {
Ok(crate::session_registry::HipUploadResult::Progress(upload_id)) => ServiceResult::HipUploadProgress {
upload_id: upload_id.to_string(),
},
Ok(crate::session_registry::HipUploadResult::Stored(report_id)) => ServiceResult::StoredHipReport {
report_id: report_id.to_string(),
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report upload"),
}
};
if control.send(ConnectionCommand::Reply { id, result }).is_err() {
pending_requests.remove(&id);
control.close(CloseReason::InternalError);
}
return Ok(());
}
if let WsRequest::ReadHipPreviewChunk(chunk) = request {
let result = Uuid::parse_str(&chunk.preview_id)
.ok()
.and_then(|preview_id| {
ctx
.registry()
.hip_preview_chunk(session_id, preview_id, chunk.offset)
.ok()
.map(|(xml, complete)| ServiceResult::HipPreviewChunk {
preview_id: preview_id.to_string(),
offset: chunk.offset,
xml,
complete,
})
})
.unwrap_or_else(|| ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "HIP preview is unavailable"));
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
return Ok(());
}
if let WsRequest::GetLastSubmittedHipReport = request {
let result = match ctx.registry().last_successful_hip_report(session_id) {
Ok(Some(report)) => match ctx.registry().store_hip_preview(session_id, report.to_string()) {
Ok(preview_id) => match ctx.registry().hip_preview_chunk(session_id, preview_id, 0) {
Ok((xml, complete)) => ServiceResult::HipPreviewChunk {
preview_id: preview_id.to_string(),
offset: 0,
xml,
complete,
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::Internal, "Submitted HIP report is unavailable"),
},
Err(_) => ServiceResult::rejected(ServiceErrorCode::Internal, "Submitted HIP report is unavailable"),
},
Ok(None) => ServiceResult::NoSubmittedHipReport,
Err(_) => ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Session is unavailable"),
};
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
return Ok(());
}
if let WsRequest::GetHipApprovalStatus { approval_id } = request {
let result = if let Some(uid) = desktop_uid.filter(|uid| *uid != 0) {
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
match gpservice::hip_approval::status(&approval_id, uid) {
Ok(status) => ServiceResult::HipApprovalStatus(status),
Err(_) => ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP approval ID"),
}
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
{
let _ = (uid, approval_id);
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "HIP script approvals are unavailable")
}
} else {
ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Desktop user is unavailable")
};
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
return Ok(());
}
if let WsRequest::PreviewHipReport(preview) = request {
let edited_report = if let HipSource::Edited { report_id } = &preview.source {
let report_id = match Uuid::parse_str(report_id) {
Ok(id) => id,
Err(_) => {
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Invalid HIP report ID"),
})
.map_err(|_| ())?;
return Ok(());
}
};
match ctx.registry().edited_hip_report(session_id, report_id) {
Ok(report) => Some(report),
Err(_) => {
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"HIP report is unavailable for this session",
),
})
.map_err(|_| ())?;
return Ok(());
}
}
} else {
None
};
if !ctx
.hip_previews
.start(crate::hip_preview::PreviewJob {
session_id,
request_id: id,
request: preview,
edited_report,
desktop_uid,
identity: ctx.host_identity().await,
registry: Arc::clone(ctx.registry()),
connection: control.clone(),
})
.await
{
control
.send(ConnectionCommand::Reply {
id,
result: ServiceResult::rejected(ServiceErrorCode::Busy, "HIP preview is already running"),
})
.map_err(|_| ())?;
}
return Ok(());
}
let dispatcher = ctx.dispatcher();
let request = match dispatcher.dispatch_lifecycle(
request,
desktop_uid,
None,
Some(crate::request_dispatcher::SessionAuthority {
registry: Arc::clone(ctx.registry()),
session_id,
generation,
}),
) {
Ok(request) => request,
Err(result) => {
if control.send(ConnectionCommand::Reply { id, result }).is_err() {
pending_requests.remove(&id);
control.close(CloseReason::InternalError);
}
return Ok(());
}
};
let control = control.clone();
tokio::spawn(async move {
let result = dispatcher.dispatch_pending(request).await;
let result = dispatcher.dispatch(request).await;
control.send_reply(id, result).await;
});
Ok(())
@@ -579,7 +396,7 @@ mod tests {
},
utils::redact::Redaction,
};
use tokio::sync::watch;
use tokio::sync::{mpsc, watch};
use tokio_tungstenite::{connect_async, tungstenite::Message as ClientFrame};
use super::*;
@@ -590,9 +407,10 @@ mod tests {
#[tokio::test]
async fn authenticates_attaches_and_replies_to_a_request() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap();
let (request_tx, mut request_rx) = mpsc::channel(4);
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
request_tx,
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
true,
@@ -614,7 +432,6 @@ mod tests {
let (mut socket, _) = connect_async(format!("ws://{address}/ws")).await.unwrap();
let prelude = ClientPrelude {
product_version: env!("CARGO_PKG_VERSION").to_owned(),
hip_protocol_version: gpapi::service::transport::HIP_PROTOCOL_VERSION,
service_instance_id: credential.service_instance_id(),
session_id: credential.session_id(),
};
@@ -658,6 +475,7 @@ mod tests {
.send(ClientFrame::Binary(noise.encrypt(&request).unwrap().into()))
.await
.unwrap();
assert!(matches!(request_rx.recv().await, Some(WsRequest::UpdateLogLevel(_))));
let reply = noise
.decrypt::<ServerMessage>(&receive_client_binary(&mut socket).await)
.unwrap();
+10 -14
View File
@@ -12,7 +12,7 @@ use gpapi::{
utils::lock_file::LockFile,
};
use log::{info, warn};
use openconnect::find_vpnc_script;
use openconnect::{find_csd_wrapper, find_vpnc_script};
use tokio::{
net::TcpListener,
sync::{Mutex, Semaphore, mpsc, oneshot, watch},
@@ -39,7 +39,6 @@ pub(crate) struct WsServerContext {
dispatcher: Arc<RequestDispatcher>,
state: Mutex<ServiceState>,
handshake_slots: Arc<Semaphore>,
pub(crate) hip_previews: crate::hip_preview::HipPreviews,
}
impl WsServerContext {
@@ -59,7 +58,6 @@ impl WsServerContext {
connections: HashMap::new(),
}),
handshake_slots: Arc::new(Semaphore::new(16)),
hip_previews: crate::hip_preview::HipPreviews::new(),
}
}
@@ -67,10 +65,6 @@ impl WsServerContext {
self.product_version
}
pub async fn host_identity(&self) -> HostIdentity {
self.state.lock().await.snapshot.host_info.host_identity.clone()
}
pub fn registry(&self) -> &Arc<SessionRegistry> {
&self.registry
}
@@ -151,8 +145,8 @@ impl WsServerContext {
}
pub async fn remove_connection(&self, connection_id: Uuid, session_id: Uuid, generation: u64) {
self.registry.disconnect_if_current(session_id, generation);
self.state.lock().await.connections.remove(&connection_id);
self.registry.disconnect_if_current(session_id, generation);
}
pub async fn send_event(&self, event: WsEvent) {
@@ -249,7 +243,6 @@ impl WsServer {
info!("WS server cancelled");
}
}
self.ctx.hip_previews.shutdown().await;
let _ = shutdown_tx.send(()).await;
}
@@ -265,7 +258,8 @@ impl WsServer {
fn build_snapshot(vpn_state: VpnState) -> VpnEnv {
VpnEnv {
vpn_state,
vpnc_script: find_vpnc_script(),
vpnc_script: find_vpnc_script().map(ToOwned::to_owned),
csd_wrapper: find_csd_wrapper().map(ToOwned::to_owned),
auth_executable: binary_paths::gpauth().to_string_lossy().into_owned(),
host_info: HostInfo {
host_identity: HostIdentity::collect(),
@@ -288,7 +282,7 @@ mod tests {
#[tokio::test]
async fn resync_snapshot_is_ordered_with_state_events() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap();
let permit = registry
.begin_handshake(
credential.service_instance_id(),
@@ -296,8 +290,9 @@ mod tests {
credential.product_version(),
)
.unwrap();
let (request_tx, _request_rx) = mpsc::channel(1);
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
request_tx,
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
true,
@@ -345,9 +340,10 @@ mod tests {
#[tokio::test]
async fn removed_prepared_candidate_cannot_commit_takeover() {
let registry = Arc::new(SessionRegistry::new(Uuid::new_v4()));
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let credential = registry.issue(env!("CARGO_PKG_VERSION")).unwrap();
let (request_tx, _request_rx) = mpsc::channel(1);
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
request_tx,
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
true,
@@ -1,7 +1,4 @@
use std::{
os::unix::process::CommandExt,
process::{Command, Stdio},
};
use std::process::{Command, Stdio};
use anyhow::Context;
use log::{debug, info, warn};
@@ -142,7 +139,6 @@ fn open_with_launcher(url: &str, launcher: &BrowserLauncher) -> anyhow::Result<(
info!("Launching Flatpak browser: {app_id}");
Command::new(executable)
.args(["run", app_id, url])
.process_group(0)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
+1 -45
View File
@@ -9,8 +9,6 @@ use std::{
))]
use crate::constants::GP_DOWNLOADED_GUI_BINARY;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use crate::constants::GP_HIP_SCRIPT_INSTALLER_BINARY;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use crate::constants::GP_VPNC_SCRIPT_INSTALLER_BINARY;
use crate::constants::{GP_AUTH_BINARY, GP_CLIENT_BINARY, GP_GUI_BINARY, GP_GUI_HELPER_BINARY, GP_SERVICE_BINARY};
@@ -31,15 +29,6 @@ pub fn gp_vpnc_script_installer() -> PathBuf {
)
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
pub fn gp_hip_script_installer() -> PathBuf {
resolve(
"GP_HIP_SCRIPT_INSTALLER_BINARY",
"gp-hip-script-installer",
GP_HIP_SCRIPT_INSTALLER_BINARY,
)
}
pub fn gpauth() -> PathBuf {
resolve("GP_AUTH_BINARY", "gpauth", GP_AUTH_BINARY)
}
@@ -82,27 +71,8 @@ fn sibling_binary(binary_name: &str) -> Option<PathBuf> {
let current_exe = env::current_exe().ok()?;
let bin_dir = current_exe.parent()?;
let binary = bin_dir.join(binary_name);
if is_file(&binary) {
return Some(binary);
}
#[cfg(target_os = "macos")]
if let Some(binary) = bundled_helper_path(&current_exe, binary_name)
&& is_file(&binary)
{
return Some(binary);
}
None
}
#[cfg(target_os = "macos")]
fn bundled_helper_path(executable: &Path, binary_name: &str) -> Option<PathBuf> {
let bin_dir = executable.parent()?;
let contents = bin_dir.parent()?;
let bundle = contents.parent()?;
if bin_dir.file_name()? != "MacOS" || contents.file_name()? != "Contents" || bundle.extension()? != "app" {
return None;
}
Some(contents.join("Helpers").join(binary_name))
is_file(&binary).then_some(binary)
}
fn is_file(path: &Path) -> bool {
@@ -113,20 +83,6 @@ fn is_file(path: &Path) -> bool {
mod tests {
use super::*;
#[test]
#[cfg(target_os = "macos")]
fn desktop_resolves_helpers_in_the_actual_app_bundle_layout() {
assert_eq!(
bundled_helper_path(
Path::new("/Applications/GP Connect.app/Contents/MacOS/gpgui"),
"gpclient"
),
Some(PathBuf::from("/Applications/GP Connect.app/Contents/Helpers/gpclient"))
);
assert!(bundled_helper_path(Path::new("/usr/local/bin/gpgui"), "gpclient").is_none());
assert!(bundled_helper_path(Path::new("/tmp/Contents/MacOS/gpgui"), "gpclient").is_none());
}
#[test]
fn default_path_is_used_when_no_sibling_exists() {
let path = resolve("GP_TEST_BINARY", "missing-gp-test-binary", "/usr/bin/gp-test");
-5
View File
@@ -6,10 +6,6 @@ pub const GP_SERVICE_LOCK_FILE: &str = "/var/run/gpservice.lock";
#[cfg(target_os = "linux")]
pub const GP_VPNC_SCRIPT_INSTALLER_BINARY: &str = "/usr/libexec/gpclient/gp-vpnc-script-installer";
#[cfg(target_os = "linux")]
pub const GP_HIP_SCRIPT_INSTALLER_BINARY: &str = "/usr/libexec/gpclient/gp-hip-script-installer";
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
pub const GP_HIP_SCRIPT_INSTALLER_BINARY: &str = "/usr/local/libexec/gpclient/gp-hip-script-installer";
#[cfg(target_os = "linux")]
pub const INSTALLED_VPNC_SCRIPT: &str = "/var/lib/gpclient/scripts/vpnc-script";
#[cfg(target_os = "linux")]
pub const INSTALLED_VPNC_SCRIPT_METADATA: &str = "/var/lib/gpclient/scripts/vpnc-script.metadata";
@@ -20,7 +16,6 @@ pub const INSTALLED_VPNC_SCRIPT: &str = "/var/db/gpclient/scripts/vpnc-script";
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
pub const INSTALLED_VPNC_SCRIPT_METADATA: &str = "/var/db/gpclient/scripts/vpnc-script.metadata";
pub const MAX_VPNC_SCRIPT_SIZE: usize = 1024 * 1024;
pub const MAX_HIP_SCRIPT_SIZE: usize = 1024 * 1024;
// Release binaries - macOS (Apple Silicon Homebrew)
#[cfg(all(not(debug_assertions), target_os = "macos", target_arch = "aarch64"))]
+1 -5
View File
@@ -6,7 +6,6 @@ edition.workspace = true
license = "MIT"
[dependencies]
nix = { version = "0.31", features = ["fs", "signal", "process"] }
common = { path = "../common" }
anyhow.workspace = true
base64.workspace = true
@@ -18,10 +17,9 @@ version-compare = "0.2"
pem.workspace = true
xmltree.workspace = true
serde.workspace = true
specta = { workspace = true, features = ["derive", "uuid"] }
specta = { workspace = true, features = ["derive"] }
urlencoding.workspace = true
tokio = { workspace = true, features = ["process", "signal", "macros"] }
tokio-util.workspace = true
serde_json.workspace = true
whoami.workspace = true
tempfile.workspace = true
@@ -38,7 +36,6 @@ uuid = { workspace = true, features = ["v4", "v5", "serde"] }
chrono.workspace = true
humantime.workspace = true
netdev.workspace = true
socket2 = { version = "0.6", features = ["all"] }
os_info = { version = "3", default-features = false }
snow.workspace = true
zeroize = { workspace = true, features = ["serde"] }
@@ -61,7 +58,6 @@ gtk = { version = "0.18", optional = true }
[dev-dependencies]
proptest.workspace = true
tokio = { workspace = true, features = ["test-util"] }
[features]
tauri = ["dep:tauri", "dep:gtk"]
-109
View File
@@ -1,109 +0,0 @@
//! Neutral device-anchor transport model and deterministic derivation.
use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(try_from = "u8", into = "u8")]
pub enum AnchorSource {
UnixMac,
UnixRandom,
MacosIokit,
}
impl From<AnchorSource> for u8 {
fn from(source: AnchorSource) -> Self {
match source {
AnchorSource::UnixMac => 1,
AnchorSource::UnixRandom => 2,
AnchorSource::MacosIokit => 3,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InvalidAnchorSource(u8);
impl fmt::Display for InvalidAnchorSource {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "unsupported device anchor source {}", self.0)
}
}
impl std::error::Error for InvalidAnchorSource {}
impl TryFrom<u8> for AnchorSource {
type Error = InvalidAnchorSource;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
1 => Ok(Self::UnixMac),
2 => Ok(Self::UnixRandom),
3 => Ok(Self::MacosIokit),
value => Err(InvalidAnchorSource(value)),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DeviceAnchor {
pub hardware_id: String,
pub source: AnchorSource,
}
impl DeviceAnchor {
pub fn validate(&self) -> bool {
URL_SAFE_NO_PAD
.decode(&self.hardware_id)
.is_ok_and(|bytes| bytes.len() == 32 && URL_SAFE_NO_PAD.encode(&bytes) == self.hardware_id)
}
pub fn derive(source: AnchorSource, seed: impl AsRef<[u8]>) -> Self {
let domain = match source {
AnchorSource::UnixMac => b"gp-device-anchor:v1:unix-mac:".as_slice(),
AnchorSource::UnixRandom => b"gp-device-anchor:v1:unix-random:".as_slice(),
AnchorSource::MacosIokit => b"gp-device-anchor:v1:macos-platform-uuid:".as_slice(),
};
let mut input = domain.to_vec();
input.extend_from_slice(seed.as_ref());
Self {
hardware_id: URL_SAFE_NO_PAD.encode(openssl::sha::sha256(&input)),
source,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hashes_original_seed_order_with_stable_domain_separation() {
let mac = DeviceAnchor::derive(AnchorSource::UnixMac, [0, 17, 34, 51, 68, 85]);
assert!(mac.validate());
assert_eq!(mac.hardware_id, "UWDOx4AVJEuCAYfJBaPioyGtRfAkJBhMYSi8LuFsE1A");
assert_ne!(
mac.hardware_id,
DeviceAnchor::derive(AnchorSource::UnixMac, [85, 68, 51, 34, 17, 0]).hardware_id
);
assert_ne!(
mac.hardware_id,
DeviceAnchor::derive(AnchorSource::UnixRandom, [0, 17, 34, 51, 68, 85]).hardware_id
);
}
#[test]
fn source_uses_stable_numeric_json_codes() {
assert_eq!(serde_json::to_string(&AnchorSource::UnixMac).unwrap(), "1");
assert_eq!(serde_json::to_string(&AnchorSource::UnixRandom).unwrap(), "2");
assert_eq!(serde_json::to_string(&AnchorSource::MacosIokit).unwrap(), "3");
assert_eq!(
serde_json::from_str::<AnchorSource>("1").unwrap(),
AnchorSource::UnixMac
);
assert!(serde_json::from_str::<AnchorSource>("0").is_err());
assert!(serde_json::from_str::<AnchorSource>("4").is_err());
assert!(serde_json::from_str::<AnchorSource>(r#""unix_mac""#).is_err());
}
}
+60 -565
View File
@@ -1,15 +1,10 @@
use std::{
borrow::Cow,
net::{SocketAddr, UdpSocket},
};
use std::{borrow::Cow, net::UdpSocket};
use anyhow::bail;
use log::{debug, info, warn};
use reqwest::Client;
use tokio_util::sync::CancellationToken;
use urlencoding::{decode, encode};
use xmltree::Element;
use zeroize::Zeroizing;
use crate::{
credential::Credential,
@@ -17,238 +12,68 @@ use crate::{
gateway::GatewayLoginContext,
gp_params::GpParams,
params::gateway_login::{self, GatewayLoginInput},
session::{
GatewayAuthentication,
network::GatewayBinding,
transport::{bound_client, gateway_origin},
},
utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::ElementExt},
};
pub enum GatewayLogin {
Authenticated(GatewayAuthentication),
Cookie(String),
Mfa(String, String),
}
/// Protocol failures cannot be repaired by repeating login with different
/// credentials. Issued credentials, when identifiable, are cleaned up first.
#[derive(Debug, thiserror::Error)]
#[error("Gateway login returned invalid session configuration")]
pub struct GatewayLoginProtocolError;
#[derive(Clone)]
pub struct GatewayLoginClient {
origin: reqwest::Url,
client: Client,
params: GpParams,
binding: Option<GatewayBinding>,
login_endpoint: Option<SocketAddr>,
login_url: Option<reqwest::Url>,
maintenance_client: Option<Client>,
pub async fn gateway_login(gateway: &str, cred: &Credential, gp_params: &GpParams) -> anyhow::Result<GatewayLogin> {
gateway_login_with_options(gateway, cred, gp_params, None, false).await
}
impl GatewayLoginClient {
pub fn register_session(
&self,
gateway: crate::gateway::Gateway,
authentication: GatewayAuthentication,
sessions: &mut crate::session::GatewaySessions,
) {
sessions.register(crate::session::GatewaySession {
gateway,
transport: self.authenticated_transport(authentication),
addresses: self
.binding
.as_ref()
.map(|binding| binding.addresses())
.unwrap_or_default(),
});
}
pub fn new(gateway: &str, params: GpParams) -> anyhow::Result<Self> {
let origin = reqwest::Url::parse(&normalize_server(gateway)?)?;
let client = Client::try_from(&params)?;
Ok(Self {
origin,
client,
params,
binding: None,
login_endpoint: None,
login_url: None,
maintenance_client: None,
})
}
/// Only called after an authenticated non-tunnel response and registration in
/// the caller's cleanup ledger. Tunnel login never inspects physical routing.
pub async fn bind_non_tunnel(
&mut self,
disable_ipv6: bool,
detection: Option<&crate::session::network::InternalHostDetection>,
cancellation: &tokio_util::sync::CancellationToken,
) -> anyhow::Result<()> {
let origin = gateway_origin(self.origin.as_str())?;
let response_url = self
.login_url
.as_ref()
.ok_or_else(|| anyhow::anyhow!("Authenticated response endpoint is unavailable"))?;
anyhow::ensure!(
response_url.origin() == origin.origin(),
"Redirected non-tunnel authentication is unsupported"
);
let endpoint = self
.login_endpoint
.ok_or_else(|| anyhow::anyhow!("Non-tunnel authentication has no direct peer address"))?;
let network = crate::session::network::PhysicalNetwork::capture_controlled(cancellation).await?;
let binding = network
.bind_authenticated_endpoint(origin.as_str(), endpoint, disable_ipv6, cancellation)
.await?;
network
.validate_internal_binding(&binding, detection, cancellation)
.await?;
let client = bound_client(origin.as_str(), &self.params, &binding)?;
self.binding = Some(binding);
self.maintenance_client = Some(client);
Ok(())
}
pub fn update_registered_session(
&self,
gateway: &crate::gateway::Gateway,
authentication: &GatewayAuthentication,
sessions: &mut crate::session::GatewaySessions,
) {
sessions.update(crate::session::GatewaySession {
gateway: gateway.clone(),
transport: self.authenticated_transport(authentication.clone()),
addresses: self
.binding
.as_ref()
.map(|binding| binding.addresses())
.unwrap_or_default(),
});
}
pub fn authenticated_transport(
&self,
authentication: GatewayAuthentication,
) -> crate::session::transport::GatewayTransport {
crate::session::transport::GatewayTransport::from_authenticated_login(
self.maintenance_client.as_ref().unwrap_or(&self.client).clone(),
self.origin.clone(),
authentication,
self.params.os_profile().clone(),
)
}
pub fn binding(&self) -> Option<&GatewayBinding> {
self.binding.as_ref()
}
pub fn client_identity(&self) -> Option<&crate::utils::request::ClientIdentity> {
self.params.client_identity()
}
pub(crate) fn request_client(&self) -> &Client {
&self.client
}
pub(crate) fn origin(&self) -> &reqwest::Url {
&self.origin
}
pub fn respond_mfa(&mut self, input: &str, otp: &str) {
self.params.set_input_str(input);
self.params.set_otp(otp);
}
pub async fn login(
&mut self,
cred: &Credential,
context: Option<&GatewayLoginContext>,
cancellation: &CancellationToken,
) -> anyhow::Result<GatewayLogin> {
if cancellation.is_cancelled() {
return Err(crate::auth::AuthenticationCancelled.into());
}
let client_ip = context.and_then(|context| {
context
.client_ip()
.map(str::to_owned)
.or_else(|| detect_local_ipv4(context.host()))
});
let request = receive_gateway_login(
&self.origin,
&self.client,
cred,
&self.params,
context,
client_ip.as_deref(),
false,
);
let response = tokio::select! {
biased;
response = request => response?,
_ = cancellation.cancelled() => return Err(crate::auth::AuthenticationCancelled.into()),
};
// Once the full response is available, retain issued authentication or finish
// cleanup-only logout before the caller observes cancellation.
let response = parse_login_response(response, &self.client, &self.origin, &self.params).await?;
self.login_endpoint = response.endpoint;
self.login_url = Some(response.url);
Ok(response.login)
}
pub(crate) async fn extend_lifetime(&self, cred: &Credential) -> anyhow::Result<GatewayLogin> {
let response = receive_gateway_login(&self.origin, &self.client, cred, &self.params, None, None, true).await?;
Ok(
parse_login_response(response, &self.client, &self.origin, &self.params)
.await?
.login,
)
}
pub async fn gateway_login_with_context(
gateway: &str,
cred: &Credential,
gp_params: &GpParams,
context: &GatewayLoginContext,
) -> anyhow::Result<GatewayLogin> {
gateway_login_with_options(gateway, cred, gp_params, Some(context), false).await
}
struct LoginResponse {
login: GatewayLogin,
endpoint: Option<SocketAddr>,
url: reqwest::Url,
pub async fn gateway_login_with_extend_lifetime(
gateway: &str,
cred: &Credential,
gp_params: &GpParams,
) -> anyhow::Result<GatewayLogin> {
gateway_login_with_options(gateway, cred, gp_params, None, true).await
}
struct ReceivedLogin {
body: String,
endpoint: Option<SocketAddr>,
url: reqwest::Url,
}
fn detect_local_ipv4(host: &str) -> Option<String> {
let socket = UdpSocket::bind("0.0.0.0:0").ok()?;
socket.connect((host, 443)).ok()?;
let ip = socket.local_addr().ok()?.ip();
if ip.is_ipv4() { Some(ip.to_string()) } else { None }
}
async fn receive_gateway_login(
origin: &reqwest::Url,
client: &Client,
async fn gateway_login_with_options(
gateway: &str,
cred: &Credential,
gp_params: &GpParams,
context: Option<&GatewayLoginContext>,
client_ip: Option<&str>,
extend_lifetime: bool,
) -> anyhow::Result<ReceivedLogin> {
let gateway = remove_url_scheme(origin.as_str().trim_end_matches('/'));
let login_url = format!("{}/ssl-vpn/login.esp", origin.as_str().trim_end_matches('/'));
) -> anyhow::Result<GatewayLogin> {
let url = normalize_server(gateway)?;
let gateway = remove_url_scheme(&url);
let login_url = format!("{}/ssl-vpn/login.esp", url);
let client = Client::try_from(gp_params)?;
let client_ip = context.and_then(|context| {
context
.client_ip()
.map(|ip| ip.to_string())
.or_else(|| detect_local_ipv4(context.host()))
});
let request_params = gateway_login::build(&GatewayLoginInput {
gp_params,
cred,
gateway_host: &gateway,
context,
client_ip,
client_ip: client_ip.as_deref(),
extend_lifetime,
});
info!("Perform gateway login, user_agent: {}", gp_params.user_agent());
log_gateway_login_context(context, client_ip, gp_params);
log_gateway_login_context(context, client_ip.as_deref(), gp_params);
let res = client
.post(login_url)
.post(&login_url)
.form(&request_params.body)
.send()
.await
@@ -257,32 +82,11 @@ async fn receive_gateway_login(
anyhow::anyhow!(PortalError::NetworkError(e))
})?;
let endpoint = res.remote_addr();
let url = res.url().clone();
let res = parse_gp_response(res).await.map_err(|err| {
warn!("Gateway login response failed: {}", err.reason);
warn!("{err}");
anyhow::anyhow!("Gateway login error: {}", err.reason)
})?;
Ok(ReceivedLogin {
body: res,
endpoint,
url,
})
}
async fn parse_login_response(
response: ReceivedLogin,
client: &Client,
origin: &reqwest::Url,
gp_params: &GpParams,
) -> anyhow::Result<LoginResponse> {
let ReceivedLogin {
body: res,
endpoint,
url,
} = response;
// It's possible to get an empty response, log the response headers for debugging
if res.trim().is_empty() {
info!("Empty gateway login response headers: {:?}", res);
@@ -292,47 +96,27 @@ async fn parse_login_response(
// MFA detected
if res.contains("Challenge") {
let Some((message, input_str)) = parse_mfa(&res) else {
bail!("Failed to parse MFA challenge");
bail!("Failed to parse MFA challenge: {res}");
};
return Ok(LoginResponse {
login: GatewayLogin::Mfa(message, input_str),
endpoint,
url,
});
return Ok(GatewayLogin::Mfa(message, input_str));
}
let lower = res.to_ascii_lowercase();
if lower.contains("<!doctype") || lower.contains("<!entity") {
return Err(GatewayLoginProtocolError.into());
}
let root = Element::parse(res.as_bytes()).map_err(|_| GatewayLoginProtocolError)?;
let (cookie, connection_type) =
parse_issued_authentication(&root, gp_params.computer()).map_err(|_| GatewayLoginProtocolError)?;
let cookie = Zeroizing::new(cookie);
let authentication = connection_type.and_then(|mode| GatewayAuthentication::new(cookie.to_string(), mode));
let authentication = match authentication {
Ok(authentication) => authentication,
Err(_) => {
match tokio::time::timeout(
std::time::Duration::from_secs(5),
crate::session::transport::logout_cookie(client, origin, &cookie, gp_params.os_profile()),
)
.await
{
Ok(Ok(())) => {}
Ok(Err(error)) => warn!("Cleanup-only gateway logout failed: {error}"),
Err(_) => warn!("Cleanup-only gateway logout timed out"),
}
return Err(GatewayLoginProtocolError.into());
}
};
debug!("Gateway login succeeded, mode: {:?}", authentication.mode());
Ok(LoginResponse {
login: GatewayLogin::Authenticated(authentication),
endpoint,
url,
})
debug!("Gateway login response: {}", res);
let root = Element::parse(res.as_bytes())?;
let cookie = build_gateway_token(&root, gp_params.computer())?;
Ok(GatewayLogin::Cookie(cookie))
}
fn detect_local_ipv4(host: &str) -> Option<String> {
let socket = UdpSocket::bind("0.0.0.0:0").ok()?;
socket.connect((host, 443)).ok()?;
let ip = socket.local_addr().ok()?.ip();
if ip.is_ipv4() { Some(ip.to_string()) } else { None }
}
fn log_gateway_login_context(context: Option<&GatewayLoginContext>, client_ip: Option<&str>, gp_params: &GpParams) {
@@ -352,33 +136,13 @@ fn log_gateway_login_context(context: Option<&GatewayLoginContext>, client_ip: O
);
}
fn parse_issued_authentication(element: &Element, computer: &str) -> anyhow::Result<(String, anyhow::Result<String>)> {
anyhow::ensure!(element.name == "jnlp", "Gateway login response is not JNLP");
anyhow::ensure!(
element.attr("status").is_none_or(|status| status == "success"),
"Gateway login response rejected authentication"
);
let application = element
.child("application-desc")
.ok_or_else(|| anyhow::anyhow!("Gateway login response has no application description"))?;
let args = application
.children("argument")
fn build_gateway_token(element: &Element, computer: &str) -> anyhow::Result<String> {
let args = element
.descendants("argument")
.iter()
.map(|e| e.get_text().unwrap_or_default())
.collect::<Vec<_>>();
let cookie = build_gateway_token(&args, computer)?;
let connection_type = read_arg_value(&args, 12)
.and_then(|mode| mode.ok_or_else(|| anyhow::anyhow!("Gateway login response has no connection type")));
Ok((cookie, connection_type))
}
#[cfg(test)]
fn parse_gateway_authentication(element: &Element, computer: &str) -> anyhow::Result<GatewayAuthentication> {
let (cookie, mode) = parse_issued_authentication(element, computer)?;
GatewayAuthentication::new(cookie, mode?)
}
fn build_gateway_token(args: &[Cow<'_, str>], computer: &str) -> anyhow::Result<String> {
let mut params = vec![
read_required_arg(&args, 1, "authcookie")?,
read_optional_arg(&args, 2, "persistent-cookie")?,
@@ -434,15 +198,11 @@ fn read_arg_value(args: &[Cow<'_, str>], index: usize) -> anyhow::Result<Option<
}
fn normalize_arg_value(value: &str) -> anyhow::Result<Option<String>> {
let value = decode(value)?;
if value.is_empty() || value == "(null)" || value == "-1" {
return Ok(None);
}
anyhow::ensure!(
!value.chars().any(char::is_control),
"Gateway argument contains control characters"
);
Ok(Some(value.into_owned()))
Ok(Some(decode(value)?.into_owned()))
}
fn parse_mfa(res: &str) -> Option<(String, String)> {
@@ -463,268 +223,6 @@ fn parse_mfa(res: &str) -> Option<(String, String)> {
mod tests {
use super::*;
fn tunnel_response() -> String {
let root = login_response(Some("tunnel"), "issued-cookie");
let mut xml = Vec::new();
root.write(&mut xml).unwrap();
crate::session::transport::tests::response(std::str::from_utf8(&xml).unwrap())
}
fn test_params() -> GpParams {
GpParams::builder(crate::os_profile::OsProfile::builder(crate::os_profile::ClientOs::Linux).build()).build()
}
#[tokio::test]
async fn gateway_login_cancels_stalled_headers_and_body() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
for partial_response in ["", "HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n<jnlp>"] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = format!("http://{}", listener.local_addr().unwrap());
let (ready, received) = tokio::sync::oneshot::channel();
let (release, released) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut buffer = [0; 4096];
assert!(socket.read(&mut buffer).await.unwrap() > 0);
socket.write_all(partial_response.as_bytes()).await.unwrap();
ready.send(()).unwrap();
released.await.unwrap();
});
let cancellation = CancellationToken::new();
let token = cancellation.clone();
let login = tokio::spawn(async move {
let mut client = GatewayLoginClient::new(&origin, test_params()).unwrap();
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
client.login(&credential, None, &token).await
});
received.await.unwrap();
cancellation.cancel();
let result = tokio::time::timeout(std::time::Duration::from_secs(1), login)
.await
.unwrap()
.unwrap();
assert!(result.err().unwrap().is::<crate::auth::AuthenticationCancelled>());
release.send(()).unwrap();
server.await.unwrap();
}
}
#[tokio::test]
async fn cancellation_during_cleanup_only_logout_awaits_cleanup() {
use crate::session::transport::tests::response;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = format!("http://{}", listener.local_addr().unwrap());
let mut xml = Vec::new();
login_response(None, "issued-cookie").write(&mut xml).unwrap();
let login_response = response(std::str::from_utf8(&xml).unwrap());
let (ready, received) = tokio::sync::oneshot::channel();
let (release, released) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut buffer = [0; 4096];
assert!(socket.read(&mut buffer).await.unwrap() > 0);
socket.write_all(login_response.as_bytes()).await.unwrap();
drop(socket);
let (mut socket, _) = listener.accept().await.unwrap();
let read = socket.read(&mut buffer).await.unwrap();
assert!(
std::str::from_utf8(&buffer[..read])
.unwrap()
.contains("/ssl-vpn/logout.esp")
);
ready.send(()).unwrap();
released.await.unwrap();
socket
.write_all(response("<response status='success'/>").as_bytes())
.await
.unwrap();
});
let cancellation = CancellationToken::new();
let token = cancellation.clone();
let mut login = tokio::spawn(async move {
let mut client = GatewayLoginClient::new(&origin, test_params()).unwrap();
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
client.login(&credential, None, &token).await
});
received.await.unwrap();
cancellation.cancel();
assert!(
tokio::time::timeout(std::time::Duration::from_millis(20), &mut login)
.await
.is_err()
);
release.send(()).unwrap();
assert!(login.await.unwrap().err().unwrap().is::<GatewayLoginProtocolError>());
server.await.unwrap();
}
#[tokio::test]
async fn ordinary_tunnel_login_follows_redirects_without_physical_binding() {
let (_, origin, server) = crate::session::transport::tests::login_gateway(vec![
"HTTP/1.1 307 Temporary Redirect\r\nLocation: /redirected-login\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(),
tunnel_response(),
"HTTP/1.1 307 Temporary Redirect\r\nLocation: /redirected-login\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(),
tunnel_response(),
]).await;
let mut client = GatewayLoginClient::new(origin.as_str(), test_params()).unwrap();
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
assert!(
matches!(client.login(&credential, None, &CancellationToken::new()).await.unwrap(), GatewayLogin::Authenticated(authentication) if authentication.mode() == crate::session::SessionMode::Tunnel)
);
assert!(client.binding().is_none());
assert!(matches!(
client.extend_lifetime(&credential).await.unwrap(),
GatewayLogin::Authenticated(_)
));
let requests = server.await.unwrap();
assert_eq!(requests[0].0, "/ssl-vpn/login.esp");
assert_eq!(requests[1].0, "/redirected-login");
assert_eq!(requests[3].0, "/redirected-login");
assert!(requests[3].1.contains("extend-lifetime=true"));
}
#[tokio::test]
async fn ordinary_login_keeps_reqwest_address_fallback() {
let (_, origin, server) = crate::session::transport::tests::login_gateway(vec![tunnel_response()]).await;
let port = origin.port().unwrap();
let params = test_params();
let mut client = GatewayLoginClient::new(&format!("http://gateway.invalid:{port}"), params.clone()).unwrap();
// Supply deterministic DNS candidates; all other client behavior is the
// ordinary request path. The first address refuses, the second is reachable.
client.client = params
.client_builder()
.unwrap()
.no_proxy()
.resolve_to_addrs(
"gateway.invalid",
&[
SocketAddr::from((std::net::Ipv6Addr::LOCALHOST, port)),
SocketAddr::from(([127, 0, 0, 1], port)),
],
)
.build()
.unwrap();
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
assert!(matches!(
client
.login(&credential, None, &CancellationToken::new())
.await
.unwrap(),
GatewayLogin::Authenticated(_)
));
assert!(client.binding().is_none());
assert_eq!(server.await.unwrap().len(), 1);
}
#[tokio::test]
async fn ordinary_tunnel_login_can_use_a_proxy_without_local_gateway_resolution() {
let (_, proxy, server) = crate::session::transport::tests::login_gateway(vec![tunnel_response()]).await;
let params = test_params();
let mut client = GatewayLoginClient::new("http://unresolvable.invalid", params.clone()).unwrap();
client.client = params
.client_builder()
.unwrap()
.proxy(reqwest::Proxy::all(proxy.as_str()).unwrap())
.build()
.unwrap();
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
assert!(matches!(
client
.login(&credential, None, &CancellationToken::new())
.await
.unwrap(),
GatewayLogin::Authenticated(_)
));
assert!(client.binding().is_none());
assert_eq!(
server.await.unwrap()[0].0,
"http://unresolvable.invalid/ssl-vpn/login.esp"
);
}
#[tokio::test]
async fn invalid_mode_logs_out_issued_cookie_before_returning_protocol_error() {
use crate::session::transport::tests::{login_gateway, response};
let root = login_response(None, "issued-cookie");
let mut xml = Vec::new();
root.write(&mut xml).unwrap();
let (client, origin, server) = login_gateway(vec![
response(std::str::from_utf8(&xml).unwrap()),
response("<response status='success'/>"),
])
.await;
let params =
GpParams::builder(crate::os_profile::OsProfile::builder(crate::os_profile::ClientOs::Linux).build()).build();
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
let mut client = GatewayLoginClient {
client,
..GatewayLoginClient::new(origin.as_str(), params).unwrap()
};
let error = client
.login(&credential, None, &CancellationToken::new())
.await
.err()
.unwrap();
assert!(error.is::<GatewayLoginProtocolError>());
let requests = server.await.unwrap();
assert_eq!(requests.len(), 2);
assert_eq!(requests[0].0, "/ssl-vpn/login.esp");
assert_eq!(requests[1].0, "/ssl-vpn/logout.esp");
let form: std::collections::HashMap<String, String> = serde_urlencoded::from_str(&requests[1].1).unwrap();
assert_eq!(form.get("authcookie").map(String::as_str), Some("issued-cookie"));
assert_eq!(form.get("user").map(String::as_str), Some("alice"));
}
#[test]
fn cleanup_only_parsing_does_not_salvage_server_error_authentication() {
let mut root = login_response(None, "issued-cookie");
root.attributes.insert("status".into(), "error".into());
assert!(parse_issued_authentication(&root, "computer").is_err());
for encoded in ["%28null%29", "%2D1", "%00"] {
assert!(parse_issued_authentication(&login_response(Some("tunnel"), encoded), "computer").is_err());
}
}
fn login_response(mode: Option<&str>, cookie: &str) -> Element {
let mut args = vec![""; 19];
args[1] = cookie;
args[4] = "alice";
if let Some(mode) = mode {
args[12] = mode;
}
let arguments = args
.iter()
.map(|value| format!("<argument>{value}</argument>"))
.collect::<String>();
Element::parse(format!("<jnlp><application-desc>{arguments}</application-desc></jnlp>").as_bytes()).unwrap()
}
#[test]
fn login_mode_is_independent_of_network_location() {
for (value, mode) in [
("tunnel", crate::session::SessionMode::Tunnel),
("non-tunnel", crate::session::SessionMode::NonTunnel),
("internal", crate::session::SessionMode::NonTunnel),
] {
let authentication =
parse_gateway_authentication(&login_response(Some(value), "test-cookie"), "computer").unwrap();
assert_eq!(authentication.mode(), mode);
assert_eq!(authentication.connection_type(), value);
assert!(!format!("{authentication:?}").contains("test-cookie"));
}
}
#[test]
fn login_rejects_missing_mode_or_cookie() {
for mode in [None, Some(""), Some("(null)"), Some("-1"), Some(" ")] {
assert!(parse_gateway_authentication(&login_response(mode, "test-cookie"), "computer").is_err());
}
assert!(parse_gateway_authentication(&login_response(Some("tunnel"), ""), "computer").is_err());
let response = Element::parse(b"<response status='error'/>".as_slice()).unwrap();
assert!(parse_gateway_authentication(&response, "computer").is_err());
}
#[test]
fn mfa() {
let res = r#"var respStatus = "Challenge";
@@ -765,9 +263,7 @@ thisForm.inputStr.value = "5ef64e83000119ed";"#;
"#;
let root = Element::parse(res.as_bytes()).unwrap();
let authentication = parse_gateway_authentication(&root, "metalklesk").unwrap();
let token = authentication.cookie();
assert_eq!(authentication.mode(), crate::session::SessionMode::Tunnel);
let token = build_gateway_token(&root, "metalklesk").unwrap();
assert_eq!(
token,
@@ -804,8 +300,7 @@ thisForm.inputStr.value = "5ef64e83000119ed";"#;
"#;
let root = Element::parse(res.as_bytes()).unwrap();
let authentication = parse_gateway_authentication(&root, "metalklesk").unwrap();
let token = authentication.cookie();
let token = build_gateway_token(&root, "metalklesk").unwrap();
assert_eq!(
token,
+1 -1
View File
@@ -118,7 +118,7 @@ impl GatewayLoginContext {
&self.name
}
pub fn kind(&self) -> GatewayKind {
pub(crate) fn kind(&self) -> GatewayKind {
self.kind
}
+29 -22
View File
@@ -5,13 +5,15 @@ use std::{
use anyhow::bail;
use log::{info, warn};
use reqwest::Client;
use xmltree::Element;
use crate::{
credential::Credential,
gateway::login::{GatewayLogin, GatewayLoginClient},
gateway::login::{GatewayLogin, gateway_login_with_extend_lifetime},
gp_params::GpParams,
session::SessionRequestArgs,
utils::{parse_gp_response, xml::ElementExt},
utils::{normalize_server, parse_gp_response, request::create_identity, xml::ElementExt},
};
const EXTEND_SESSION_MESSAGE: &str = "User Session Extension";
@@ -20,18 +22,12 @@ const EXTEND_SESSION_COMMENT: &str = "User extends the login lifetime";
#[derive(Clone)]
pub struct SessionExtensionAuth {
credential: Credential,
client: GatewayLoginClient,
gp_params: GpParams,
}
impl SessionExtensionAuth {
pub fn new(credential: Credential, client: GatewayLoginClient) -> Self {
Self { credential, client }
}
pub fn client_identity(&self) -> Option<&crate::utils::request::ClientIdentity> {
self.client.client_identity()
}
pub fn binding(&self) -> Option<&crate::session::network::GatewayBinding> {
self.client.binding()
pub fn new(credential: Credential, gp_params: GpParams) -> Self {
Self { credential, gp_params }
}
}
@@ -39,7 +35,7 @@ impl std::fmt::Debug for SessionExtensionAuth {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SessionExtensionAuth")
.field("username", &self.credential.username())
.field("client", &"<redacted>")
.field("gp_params", &"<redacted>")
.finish()
}
}
@@ -87,15 +83,10 @@ impl SessionContext {
pub async fn extend_session(ctx: &SessionContext) -> anyhow::Result<()> {
extend_session_lifetime(ctx).await?;
let auth = ctx
.extension_auth()
.ok_or_else(|| anyhow::anyhow!("Session extension requires retained gateway auth state"))?;
let client = auth.client.request_client();
let url = format!(
"{}/ssl-vpn/agentmessage.esp",
auth.client.origin().as_str().trim_end_matches('/')
);
let base_url = normalize_server(ctx.server())?;
let client = build_session_client(ctx.session_args())?;
let form = build_extend_session_form(ctx)?;
let url = format!("{base_url}/ssl-vpn/agentmessage.esp");
info!("Sending extend-session request");
@@ -117,17 +108,33 @@ async fn extend_session_lifetime(ctx: &SessionContext) -> anyhow::Result<()> {
.extension_auth()
.ok_or_else(|| anyhow::anyhow!("Session extension requires retained gateway auth state"))?;
let login = auth.client.extend_lifetime(&auth.credential).await?;
let login = gateway_login_with_extend_lifetime(ctx.server(), &auth.credential, &auth.gp_params).await?;
validate_extension_login(login)
}
fn validate_extension_login(login: GatewayLogin) -> anyhow::Result<()> {
match login {
GatewayLogin::Authenticated(_) => Ok(()),
GatewayLogin::Cookie(_) => Ok(()),
GatewayLogin::Mfa(_, _) => bail!("Session extension requires an interactive gateway challenge"),
}
}
fn build_session_client(args: &SessionRequestArgs) -> anyhow::Result<Client> {
let mut builder = Client::builder();
if let Some(user_agent) = args.user_agent() {
builder = builder.user_agent(user_agent);
}
if let Some(cert) = args.certificate() {
info!("Using client certificate authentication...");
let identity = create_identity(&cert, args.sslkey().as_deref(), args.key_password().as_deref())?;
builder = builder.identity(identity);
}
Ok(builder.build()?)
}
fn parse_cookie_form(args: &SessionRequestArgs) -> anyhow::Result<HashMap<String, String>> {
Ok(serde_urlencoded::from_str(args.cookie())?)
}
+14 -109
View File
@@ -1,12 +1,11 @@
use log::info;
use reqwest::{Client, ClientBuilder};
use reqwest::Client;
use serde::{Deserialize, Serialize};
use specta::Type;
use zeroize::Zeroize;
use crate::{
os_profile::{ClientOs, HostIdentity, OsProfile},
utils::request::{ClientIdentity, create_identity},
utils::request::create_identity,
};
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Type, Default)]
@@ -44,7 +43,6 @@ pub struct GpParams {
certificate: Option<String>,
sslkey: Option<String>,
key_password: Option<String>,
prepared_identity: Option<ClientIdentity>,
// Feature
csc_mode: CscMode,
// Per-request state
@@ -137,49 +135,9 @@ impl GpParams {
pub(crate) fn otp(&self) -> Option<&str> {
self.otp.as_deref()
}
pub fn prepare_client_identity(&mut self) -> anyhow::Result<()> {
if self.prepared_identity.is_none() {
if let Some(certificate) = self.certificate.as_deref() {
self.prepared_identity = Some(ClientIdentity::load(
certificate,
self.sslkey.as_deref(),
self.key_password.as_deref(),
)?);
}
}
self.certificate = None;
self.sslkey = None;
if let Some(mut passphrase) = self.key_password.take() {
passphrase.zeroize();
}
Ok(())
}
pub fn client_identity(&self) -> Option<&ClientIdentity> {
self.prepared_identity.as_ref()
}
pub(crate) fn client_builder(&self) -> anyhow::Result<ClientBuilder> {
let mut builder = Client::builder()
.danger_accept_invalid_certs(self.ignore_tls_errors)
.user_agent(self.user_agent());
if let Some(identity) = &self.prepared_identity {
builder = builder.identity(identity.request_identity());
} else if let Some(cert) = self.certificate.as_deref() {
info!("Using client certificate authentication...");
builder = builder.identity(create_identity(
cert,
self.sslkey.as_deref(),
self.key_password.as_deref(),
)?);
}
Ok(builder)
}
}
pub struct GpParamsBuilder {
prepared_identity: Option<ClientIdentity>,
is_gateway: bool,
os_profile: OsProfile,
csc_mode: CscMode,
@@ -192,7 +150,6 @@ pub struct GpParamsBuilder {
impl GpParamsBuilder {
pub fn new(os_profile: OsProfile) -> Self {
Self {
prepared_identity: None,
is_gateway: false,
os_profile,
csc_mode: Default::default(),
@@ -219,34 +176,22 @@ impl GpParamsBuilder {
}
pub fn certificate<T: Into<Option<String>>>(&mut self, certificate: T) -> &mut Self {
self.prepared_identity = None;
self.certificate = certificate.into();
self
}
pub fn sslkey<T: Into<Option<String>>>(&mut self, sslkey: T) -> &mut Self {
self.prepared_identity = None;
self.sslkey = sslkey.into();
self
}
pub fn key_password<T: Into<Option<String>>>(&mut self, password: T) -> &mut Self {
self.prepared_identity = None;
self.key_password = password.into();
self
}
pub fn client_identity(&mut self, identity: Option<ClientIdentity>) -> &mut Self {
self.prepared_identity = identity;
self.certificate = None;
self.sslkey = None;
self.key_password = None;
self
}
pub fn build(&self) -> GpParams {
GpParams {
prepared_identity: self.prepared_identity.clone(),
os_profile: self.os_profile.clone(),
ignore_tls_errors: self.ignore_tls_errors,
certificate: self.certificate.clone(),
@@ -264,64 +209,24 @@ impl TryFrom<&GpParams> for Client {
type Error = anyhow::Error;
fn try_from(value: &GpParams) -> Result<Self, Self::Error> {
Ok(value.client_builder()?.build()?)
let mut builder = Client::builder()
.danger_accept_invalid_certs(value.ignore_tls_errors)
.user_agent(value.user_agent());
if let Some(cert) = value.certificate.as_deref() {
info!("Using client certificate authentication...");
let identity = create_identity(cert, value.sslkey.as_deref(), value.key_password.as_deref())?;
builder = builder.identity(identity);
}
let client = builder.build()?;
Ok(client)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn path_identity_settings_replace_a_prepared_snapshot() {
let identity = ClientIdentity::load("tests/files/badssl.com-client.pem", None, Some("badssl.com")).unwrap();
let setters: [fn(&mut GpParamsBuilder); 3] = [
|builder| {
builder.certificate(Some("missing-replacement-certificate.pem".into()));
},
|builder| {
builder.sslkey(Some("replacement-key.pem".into()));
},
|builder| {
builder.key_password(Some("replacement-password".into()));
},
];
for setter in setters {
let mut builder = GpParams::builder(profile(ClientOs::Linux));
builder.client_identity(Some(identity.clone()));
setter(&mut builder);
let params = builder.build();
assert!(
params.client_identity().is_none(),
"Path settings must not silently use the previous identity"
);
if params.certificate.is_some() {
assert!(
Client::try_from(&params).is_err(),
"The replacement certificate path must actually be loaded"
);
}
}
}
#[test]
fn prepared_identity_replaces_paths_and_can_be_explicitly_disabled() {
let identity = ClientIdentity::load("tests/files/badssl.com-client.pem", None, Some("badssl.com")).unwrap();
let mut builder = GpParams::builder(profile(ClientOs::Linux));
builder
.certificate(Some("missing-certificate.pem".into()))
.sslkey(Some("missing-key.pem".into()))
.key_password(Some("unused-password".into()))
.client_identity(Some(identity));
let params = builder.build();
assert!(params.client_identity().is_some());
assert!(params.certificate.is_none() && params.sslkey.is_none() && params.key_password.is_none());
assert!(Client::try_from(&params).is_ok());
builder.certificate(None);
let params = builder.build();
assert!(params.client_identity().is_none());
assert!(params.certificate.is_none());
}
use crate::os_profile::runtime_client_os;
fn profile(client_os: ClientOs) -> OsProfile {
-47
View File
@@ -1,47 +0,0 @@
use serde::{Deserialize, Serialize};
use specta::Type;
/// The GUI's choice of HIP report source. gpservice resolves execution details.
#[derive(Clone, Debug, Default, Deserialize, Serialize, Type, PartialEq, Eq)]
#[serde(tag = "source", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum HipSource {
#[default]
Disabled,
Generated,
Edited {
report_id: String,
},
UserScript {
path: String,
},
ApprovedRootScript {
approval_id: String,
},
}
#[derive(Clone, Copy, Debug, Deserialize, Serialize, Type, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum HipApprovalStatus {
Valid,
Revoked,
Corrupt,
OtherUser,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn source_round_trips_without_execution_uid_or_wrapper() {
let source = HipSource::ApprovedRootScript {
approval_id: "approved-1".into(),
};
let json = serde_json::to_value(&source).unwrap();
assert_eq!(
json,
serde_json::json!({ "source": "approvedRootScript", "approvalId": "approved-1" })
);
assert_eq!(serde_json::from_value::<HipSource>(json).unwrap(), source);
}
}
-2
View File
@@ -1,11 +1,9 @@
pub mod auth;
pub mod cookie_store;
pub mod credential;
pub mod device_anchor;
pub mod error;
pub mod gateway;
pub mod gp_params;
pub mod hip;
pub mod log_format;
pub mod os_profile;
pub mod params;
+59 -125
View File
@@ -1,6 +1,3 @@
use std::{io, time::Duration};
use crate::process::collection::{CollectionBudget, CollectionControl};
use serde::{Deserialize, Serialize};
use specta::Type;
@@ -23,39 +20,8 @@ impl HostIdentity {
Self::collect_with_host_id(None)
}
pub fn collect_with_control(control: &dyn CollectionControl) -> io::Result<Self> {
Self::collect_with_host_id_and_control(None, control)
}
pub(crate) fn collect_with_host_id(host_id: Option<&str>) -> Self {
match Self::collect_with_host_id_and_control(host_id, &CollectionBudget::new(Duration::from_secs(60))) {
Ok(identity) => identity,
Err(error) => {
log::warn!("Host identity collection was unavailable: {error}");
Self::default_with_host_id(host_id)
}
}
}
/// Best-effort convenience callers retain the established derived identity
/// when native collection is unavailable. Controlled HIP callers get errors.
pub(crate) fn default_with_host_id(host_id: Option<&str>) -> Self {
Self::from_parts(
fallback_hostname(),
resolve_host_id(host_id, fallback_host_id),
String::new(),
primary_mac_colon().unwrap_or_default(),
)
}
pub(crate) fn collect_with_host_id_and_control(
host_id: Option<&str>,
control: &dyn CollectionControl,
) -> io::Result<Self> {
control.check()?;
let identity = RuntimeNativeHostIdentity::collect_with_control(host_id, control)?.into_host_identity();
control.check()?;
Ok(identity)
RuntimeNativeHostIdentity::collect(host_id).into_host_identity()
}
#[cfg(test)]
@@ -63,8 +29,7 @@ impl HostIdentity {
Self::from_parts(computer, host_id, serialno, mac_addr)
}
/// Construct a host identity from an already collected or negotiated snapshot.
pub fn from_parts(computer: String, host_id: String, serialno: String, mac_addr: String) -> Self {
pub(crate) fn from_parts(computer: String, host_id: String, serialno: String, mac_addr: String) -> Self {
let host_id = non_empty(host_id, fallback_host_id());
let computer = non_empty(computer, fallback_hostname());
let serial_number = non_empty(serialno, derive_serial_number(&host_id));
@@ -198,12 +163,12 @@ fn derive_uuid_from_seed(seed: &str, parts: &[&str]) -> String {
#[cfg(target_os = "macos")]
mod platform {
use std::process::Command;
use super::{
ClientOs, NativeHostIdentitySnapshot, derive_mac_address, fallback_hostname, normalize_mac_colon,
primary_mac_colon, resolve_host_id,
};
use crate::process::collection::{CollectionControl, CollectorCommands};
use std::io;
pub(super) struct RuntimeNativeHostIdentity;
@@ -212,80 +177,74 @@ mod platform {
ClientOs::Mac
}
pub(super) fn collect_with_control(
host_id_override: Option<&str>,
control: &dyn CollectionControl,
) -> io::Result<NativeHostIdentitySnapshot> {
let commands = CollectorCommands::new(control);
let native_mac = macos_builtin_mac(&commands)?.or_else(primary_mac_colon);
control.check()?;
pub(super) fn collect(host_id_override: Option<&str>) -> NativeHostIdentitySnapshot {
let native_mac = macos_builtin_mac().or_else(primary_mac_colon);
let host_id = resolve_host_id(host_id_override, || {
native_mac
.clone()
.unwrap_or_else(|| derive_mac_address(&fallback_hostname()))
});
let computer = macos_computer_name(&commands)?.unwrap_or_else(fallback_hostname);
let serial_number = collect_macos_serial_number(&commands)?;
control.check()?;
Ok(NativeHostIdentitySnapshot {
NativeHostIdentitySnapshot {
host_id,
computer,
serial_number,
computer: macos_computer_name().unwrap_or_else(fallback_hostname),
serial_number: collect_macos_serial_number(),
mac_address: native_mac,
})
}
}
}
fn output(commands: &CollectorCommands<'_>, program: &str, args: &[&str]) -> io::Result<Option<String>> {
Ok(
commands
.run(program, args)?
.filter(|output| output.status.success())
.and_then(|output| String::from_utf8(output.stdout).ok()),
)
}
fn macos_computer_name() -> Option<String> {
["ComputerName", "LocalHostName"].into_iter().find_map(|name| {
let output = Command::new("scutil").args(["--get", name]).output().ok()?;
if !output.status.success() {
return None;
}
fn macos_computer_name(commands: &CollectorCommands<'_>) -> io::Result<Option<String>> {
for name in ["ComputerName", "LocalHostName"] {
if let Some(value) = output(commands, "scutil", &["--get", name])?
String::from_utf8(output.stdout)
.ok()
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
{
return Ok(Some(value));
}
}
Ok(None)
})
}
fn macos_builtin_mac(commands: &CollectorCommands<'_>) -> io::Result<Option<String>> {
if let Some(stdout) = output(commands, "networksetup", &["-listallhardwareports"])? {
for name in ["Wi-Fi", "AirPort"] {
if let Some(mac) = parse_hardware_port_mac(&stdout, name) {
return Ok(Some(mac));
}
}
}
macos_system_profiler_wifi_mac(commands)
fn macos_builtin_mac() -> Option<String> {
macos_networksetup_mac("Wi-Fi")
.or_else(|| macos_networksetup_mac("AirPort"))
.or_else(macos_system_profiler_wifi_mac)
}
fn parse_hardware_port_mac(stdout: &str, name: &str) -> Option<String> {
fn macos_networksetup_mac(port_name: &str) -> Option<String> {
let output = Command::new("networksetup")
.arg("-listallhardwareports")
.output()
.ok()?;
if !output.status.success() {
return None;
}
let stdout = String::from_utf8(output.stdout).ok()?;
let mut in_port = false;
for line in stdout.lines() {
if let Some(port) = line.strip_prefix("Hardware Port: ") {
in_port = port == name;
in_port = port == port_name;
continue;
}
if in_port && let Some(mac) = line.strip_prefix("Ethernet Address: ") {
return normalize_mac_colon(mac);
}
}
None
}
fn macos_system_profiler_wifi_mac(commands: &CollectorCommands<'_>) -> io::Result<Option<String>> {
let Some(stdout) = output(commands, "system_profiler", &["SPNetworkDataType"])? else {
return Ok(None);
};
fn macos_system_profiler_wifi_mac() -> Option<String> {
let output = Command::new("system_profiler").arg("SPNetworkDataType").output().ok()?;
if !output.status.success() {
return None;
}
let stdout = String::from_utf8(output.stdout).ok()?;
let mut in_wifi = false;
for line in stdout.lines() {
let trimmed = line.trim();
@@ -293,24 +252,29 @@ mod platform {
in_wifi = trimmed == "Wi-Fi:" || trimmed == "AirPort:";
continue;
}
if in_wifi && let Some(mac) = trimmed.strip_prefix("MAC Address: ") {
return Ok(normalize_mac_colon(mac));
return normalize_mac_colon(mac);
}
}
Ok(None)
None
}
fn collect_macos_serial_number(commands: &CollectorCommands<'_>) -> io::Result<Option<String>> {
let Some(stdout) = output(commands, "ioreg", &["-rd1", "-c", "IOPlatformExpertDevice"])? else {
return Ok(None);
};
Ok(stdout.lines().find_map(|line| {
fn collect_macos_serial_number() -> Option<String> {
let output = Command::new("ioreg")
.args(["-rd1", "-c", "IOPlatformExpertDevice"])
.output()
.ok()?;
let stdout = String::from_utf8(output.stdout).ok()?;
stdout.lines().find_map(|line| {
line
.split_once("IOPlatformSerialNumber")
.and_then(|(_, value)| value.split_once('='))
.map(|(_, value)| value.trim().trim_matches('"').to_string())
.filter(|value| !value.is_empty())
}))
})
}
}
@@ -327,17 +291,7 @@ mod platform {
ClientOs::Windows
}
pub(super) fn collect_with_control(
host_id_override: Option<&str>,
control: &dyn super::CollectionControl,
) -> super::io::Result<NativeHostIdentitySnapshot> {
control.check()?;
let identity = Self::collect(host_id_override);
control.check()?;
Ok(identity)
}
fn collect(host_id_override: Option<&str>) -> NativeHostIdentitySnapshot {
pub(super) fn collect(host_id_override: Option<&str>) -> NativeHostIdentitySnapshot {
let host_id = resolve_host_id(host_id_override, Self::host_id);
NativeHostIdentitySnapshot {
host_id,
@@ -419,17 +373,7 @@ mod platform {
ClientOs::Linux
}
pub(super) fn collect_with_control(
host_id_override: Option<&str>,
control: &dyn super::CollectionControl,
) -> super::io::Result<NativeHostIdentitySnapshot> {
control.check()?;
let identity = Self::collect(host_id_override);
control.check()?;
Ok(identity)
}
fn collect(host_id_override: Option<&str>) -> NativeHostIdentitySnapshot {
pub(super) fn collect(host_id_override: Option<&str>) -> NativeHostIdentitySnapshot {
if let Some(host_id) = host_id_override.filter(|value| !value.trim().is_empty()) {
debug!("Runtime host-id source: explicit override ({})", host_id);
}
@@ -532,15 +476,6 @@ mod platform {
mod tests {
use super::*;
#[test]
fn controlled_identity_collection_propagates_cancellation() {
let control = || Err(io::Error::new(io::ErrorKind::Interrupted, "cancelled"));
let error = HostIdentity::collect_with_control(&control).unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::Interrupted);
let error = HostIdentity::collect_with_host_id_and_control(Some("supplied"), &control).unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::Interrupted);
}
#[test]
fn collect_produces_non_empty_identity() {
let identity = HostIdentity::collect();
@@ -593,8 +528,7 @@ mod tests {
#[test]
fn native_snapshot_uses_host_id_as_derivation_seed() {
let native =
RuntimeNativeHostIdentity::collect_with_control(None, &CollectionBudget::new(Duration::from_secs(60))).unwrap();
let native = RuntimeNativeHostIdentity::collect(None);
assert!(!native.host_id.is_empty());
}
+21 -114
View File
@@ -3,9 +3,6 @@ mod serial_number;
pub use host_identity::HostIdentity;
use crate::process::collection::{CollectionBudget, CollectionControl};
use std::{io, time::Duration};
use common::constants::{GP_CLIENT_VERSION_LINUX, GP_CLIENT_VERSION_MACOS, GP_CLIENT_VERSION_WINDOWS, GP_USER_AGENT};
use serde::{Deserialize, Serialize};
use specta::Type;
@@ -369,7 +366,6 @@ impl OsProfile {
pub struct OsProfileBuilder {
client_os: ClientOs,
client_version: Option<String>,
os_version_override: Option<String>,
computer_name_override: Option<String>,
host_id_override: Option<String>,
host_identity: Option<HostIdentity>,
@@ -381,7 +377,6 @@ impl OsProfileBuilder {
Self {
client_os,
client_version: None,
os_version_override: None,
computer_name_override: None,
host_id_override: None,
host_identity: None,
@@ -399,13 +394,6 @@ impl OsProfileBuilder {
self
}
/// Preserve an explicitly negotiated operating system version.
pub fn os_version(mut self, version: impl Into<String>) -> Self {
let version = version.into();
self.os_version_override = if version.trim().is_empty() { None } else { Some(version) };
self
}
pub fn host_identity(mut self, identity: HostIdentity) -> Self {
self.host_identity = Some(identity);
self
@@ -423,67 +411,31 @@ impl OsProfileBuilder {
self
}
/// Build a best-effort profile with a bounded native collection budget.
/// Use `build_with_control` when interruption or timeout must be reported.
pub fn build(self) -> OsProfile {
match self
.clone()
.build_with_control(&CollectionBudget::new(Duration::from_secs(60)))
{
Ok(profile) => profile,
Err(error) => {
log::warn!("OS profile collection was unavailable: {error}");
let identity = self
.host_identity
.clone()
.unwrap_or_else(|| HostIdentity::default_with_host_id(self.host_id_override.as_deref()));
let (os_version, software_version) = match self.client_os {
ClientOs::Mac => (
format!("Apple Mac OS X {DEFAULT_MACOS_VERSION}"),
DEFAULT_MACOS_VERSION.into(),
),
os => (target::os_version(os), target::software_version(os)),
};
self.finish(identity, os_version, software_version)
}
}
}
pub fn build_with_control(self, control: &dyn CollectionControl) -> io::Result<OsProfile> {
control.check()?;
let host_identity = match (&self.host_identity, &self.host_id_override) {
(Some(identity), _) => identity.clone(),
(None, host_id) => HostIdentity::collect_with_host_id_and_control(host_id.as_deref(), control)?,
};
let (os_version, software_version) = if self.client_os == ClientOs::Mac {
let version = macos_version_with_control(control)?;
(format!("Apple Mac OS X {version}"), version)
} else {
(
target::os_version(self.client_os),
target::software_version(self.client_os),
)
};
control.check()?;
Ok(self.finish(host_identity, os_version, software_version))
}
fn finish(self, host_identity: HostIdentity, default_os_version: String, software_version: String) -> OsProfile {
let client_version = self
.client_version
.filter(|version| !version.trim().is_empty())
.unwrap_or_else(|| self.client_os.default_client_version().into());
.filter(|v| !v.trim().is_empty())
.unwrap_or_else(|| self.client_os.default_client_version().to_string());
let host_identity = match (self.host_identity, self.host_id_override) {
(Some(identity), _) => identity,
(None, host_id) => HostIdentity::collect_with_host_id(host_id.as_deref()),
};
let profile_identity =
ProfileHostIdentity::for_client_os(self.client_os, &host_identity, self.computer_name_override);
let os_version = self.os_version_override.unwrap_or(default_os_version);
let os_version = target::os_version(self.client_os);
let software_version = target::software_version(self.client_os);
let os_vendor = target::os_vendor(self.client_os);
let user_agent = self
.user_agent
.unwrap_or_else(|| format!("{GP_USER_AGENT}/{client_version} ({os_version})"));
.unwrap_or_else(|| format!("{}/{} ({})", GP_USER_AGENT, client_version, os_version));
OsProfile {
client_os: self.client_os,
os_version,
software_version,
os_vendor: target::os_vendor(self.client_os),
os_vendor,
client_version,
host_identity,
profile_identity,
@@ -548,28 +500,14 @@ fn runtime_distro_or(fallback: &str) -> String {
}
fn macos_version() -> String {
macos_version_with_control(&CollectionBudget::new(Duration::from_secs(60))).unwrap_or_else(|error| {
log::warn!("Operating system version collection was unavailable: {error}");
DEFAULT_MACOS_VERSION.into()
})
}
fn macos_version_with_control(control: &dyn CollectionControl) -> io::Result<String> {
control.check()?;
#[cfg(target_os = "macos")]
{
let commands = crate::process::collection::CollectorCommands::new(control);
let version = commands
.run("sw_vers", &["-productVersion"])?
.filter(|output| output.status.success())
.and_then(|output| String::from_utf8(output.stdout).ok())
.map(|version| version.trim().to_string())
.filter(|version| !version.is_empty());
control.check()?;
Ok(version.unwrap_or_else(|| DEFAULT_MACOS_VERSION.into()))
if runtime_client_os() == ClientOs::Mac {
match os_info::get().version() {
os_info::Version::Unknown => DEFAULT_MACOS_VERSION.to_string(),
v => v.to_string(),
}
} else {
DEFAULT_MACOS_VERSION.to_string()
}
#[cfg(not(target_os = "macos"))]
Ok(DEFAULT_MACOS_VERSION.into())
}
fn macos_os_string() -> String {
@@ -753,37 +691,6 @@ mod target_identity {
mod tests {
use super::*;
#[test]
fn controlled_profile_collection_propagates_cancellation_and_deadline() {
let cancelled = || Err(io::Error::new(io::ErrorKind::Interrupted, "cancelled"));
let error = OsProfileBuilder::new(ClientOs::Mac)
.build_with_control(&cancelled)
.unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::Interrupted);
let expired = CollectionBudget::new(Duration::ZERO);
let error = OsProfileBuilder::new(ClientOs::Linux)
.build_with_control(&expired)
.unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::TimedOut);
}
#[test]
fn negotiated_os_version_is_used_in_profile_and_user_agent() {
let identity = HostIdentity::from_parts(
"device".into(),
"host".into(),
"serial".into(),
"00:11:22:33:44:55".into(),
);
let profile = OsProfileBuilder::new(ClientOs::Mac)
.host_identity(identity)
.client_version("6.3.3")
.os_version("negotiated-system-version")
.build();
assert_eq!(profile.os_version(), "negotiated-system-version");
assert!(profile.user_agent().contains("negotiated-system-version"));
}
#[test]
fn csc_support_defaults_match_official_profiles() {
assert!(!ClientOs::Linux.default_csc_support());
+56 -180
View File
@@ -1,11 +1,11 @@
use std::collections::HashMap;
use anyhow::bail;
use dns_lookup::lookup_addr;
use log::{debug, info, warn};
use reqwest::{Client, StatusCode};
use serde::Serialize;
use specta::Type;
use tokio_util::sync::CancellationToken;
use xmltree::Element;
use crate::{
@@ -14,7 +14,6 @@ use crate::{
gateway::{Gateway, parse_gateways},
gp_params::GpParams,
params,
session::{InternalSessionPolicy, network::InternalHostDetection},
utils::{normalize_server, parse_gp_response, redact::redact_form_params, remove_url_scheme, xml::ElementExt},
};
@@ -36,7 +35,6 @@ pub struct PortalConfig {
* - Some(true): Internal host detection is supported and the user is connected to the internal network
*/
internal_host_detection: Option<bool>,
internal_detection: Option<InternalHostDetection>,
/**
* The version returned by the portal config, if any
*/
@@ -49,7 +47,6 @@ pub struct PortalConfig {
* Whether the portal policy enables default-browser authentication.
*/
default_browser: Option<bool>,
internal_session_policy: Option<InternalSessionPolicy>,
}
impl PortalConfig {
@@ -73,10 +70,6 @@ impl PortalConfig {
self.internal_host_detection
}
pub fn internal_detection(&self) -> Option<&InternalHostDetection> {
self.internal_detection.as_ref()
}
pub fn connect_method(&self) -> Option<&str> {
self.connect_method.as_deref()
}
@@ -93,10 +86,6 @@ impl PortalConfig {
self.default_browser
}
pub fn internal_session_policy(&self) -> Option<InternalSessionPolicy> {
self.internal_session_policy
}
/// In-place sort the gateways by region
pub fn sort_gateways(&mut self, region: &str) {
let preferred_gateway = self.find_preferred_gateway(region);
@@ -140,14 +129,7 @@ impl PortalConfig {
}
}
/// Cancellation is handled inside the request so a running native detection
/// helper is always cancelled and joined. Do not drop this future on disconnect.
pub async fn retrieve_config(
portal: &str,
cred: &Credential,
gp_params: &GpParams,
cancellation: &CancellationToken,
) -> anyhow::Result<PortalConfig> {
pub async fn retrieve_config(portal: &str, cred: &Credential, gp_params: &GpParams) -> anyhow::Result<PortalConfig> {
let portal = normalize_server(portal)?;
let server = remove_url_scheme(&portal);
@@ -164,35 +146,29 @@ pub async fn retrieve_config(
info!("Retrieve the portal config, user_agent: {}", gp_params.user_agent());
info!("Portal config request params: {}", redact_form_params(&body_pairs));
let res_xml = tokio::select! {
biased;
_ = cancellation.cancelled() => bail!("Portal configuration cancelled"),
result = async {
let res = client.post(&url).form(&request_params.body).send().await.map_err(|e| {
warn!("Network error: {:?}", e);
anyhow::anyhow!(PortalError::NetworkError(e))
})?;
let res = client.post(&url).form(&request_params.body).send().await.map_err(|e| {
warn!("Network error: {:?}", e);
anyhow::anyhow!(PortalError::NetworkError(e))
})?;
parse_gp_response(res).await.or_else(|err| {
if err.status == StatusCode::NOT_FOUND {
bail!(PortalError::ConfigError("Config endpoint not found".to_string()));
}
let res_xml = parse_gp_response(res).await.or_else(|err| {
if err.status == StatusCode::NOT_FOUND {
bail!(PortalError::ConfigError("Config endpoint not found".to_string()));
}
if err.is_status_error() {
warn!("{err}");
bail!("Portal config error: {}", err.reason);
}
if err.is_status_error() {
warn!("{err}");
bail!("Portal config error: {}", err.reason);
}
Err(anyhow::anyhow!(PortalError::ConfigError(err.reason)))
})
} => result?,
};
Err(anyhow::anyhow!(PortalError::ConfigError(err.reason)))
})?;
if res_xml.is_empty() {
bail!(PortalError::ConfigError("Empty portal config response".to_string()))
}
debug!("Portal config response received: {} bytes", res_xml.len());
debug!("Portal config response: {}", res_xml);
let root = Element::parse(res_xml.as_bytes()).map_err(|e| PortalError::ConfigError(e.to_string()))?;
if csc::is_config_criteria(&root) {
@@ -202,18 +178,14 @@ pub async fn retrieve_config(
"Portal returned CSC criteria but CSC support is disabled".to_string()
));
}
let csc_xml = tokio::select! {
biased;
_ = cancellation.cancelled() => bail!("Portal configuration cancelled"),
result = retrieve_csc_config(&client, &portal, &root, cred.username(), gp_params) => result?,
};
debug!("Portal CSC config response received: {} bytes", csc_xml.len());
let csc_xml = retrieve_csc_config(&client, &portal, &root, cred.username(), gp_params).await?;
debug!("Portal CSC config response: {}", csc_xml);
let root = Element::parse(csc_xml.as_bytes()).map_err(|e| PortalError::ConfigError(e.to_string()))?;
return parse_portal_config(&server, cred, root, cancellation).await;
return parse_portal_config(&server, cred, root);
}
info!("Portal did not return CSC criteria");
parse_portal_config(&server, cred, root, cancellation).await
parse_portal_config(&server, cred, root)
}
async fn retrieve_csc_config(
@@ -273,31 +245,12 @@ fn present(value: Option<&str>) -> &'static str {
}
}
async fn parse_portal_config(
server: &str,
cred: &Credential,
root: Element,
cancellation: &CancellationToken,
) -> anyhow::Result<PortalConfig> {
let internal_detection = root
.descendant("internal-host-detection")
.map(parse_internal_detection)
.transpose()
.unwrap_or_else(|error| {
warn!("Internal host detection policy is unavailable: {error}");
None
})
.flatten();
let prefer_internal = match &internal_detection {
Some(detection) => detection.detect(cancellation).await.unwrap_or_else(|error| {
warn!("Internal host detection failed: {error}");
false
}),
None => false,
};
if cancellation.is_cancelled() {
bail!("Portal configuration cancelled");
fn parse_portal_config(server: &str, cred: &Credential, root: Element) -> anyhow::Result<PortalConfig> {
let mut ihd_enabled = false;
let mut prefer_internal = false;
if let Some(ihd_node) = root.descendant("internal-host-detection") {
ihd_enabled = true;
prefer_internal = internal_host_detect(ihd_node)
}
let mut gateways = parse_gateways(&root, prefer_internal).unwrap_or_else(|| {
@@ -322,7 +275,6 @@ async fn parse_portal_config(
info!("Detected portal version: {:?}", version);
let allow_extend_session = parse_allow_extend_session(&root);
let default_browser = parse_default_browser(&root);
let internal_session_policy = parse_internal_session_policy(&root).ok();
Ok(PortalConfig {
portal: server.to_string(),
@@ -331,42 +283,13 @@ async fn parse_portal_config(
gateways,
connect_method,
config_digest: config_digest.map(|s| s.to_string()),
internal_host_detection: internal_detection.as_ref().map(|_| prefer_internal),
internal_detection,
internal_host_detection: if ihd_enabled { Some(prefer_internal) } else { None },
version,
allow_extend_session,
default_browser,
internal_session_policy,
})
}
fn parse_internal_session_policy(root: &Element) -> anyhow::Result<InternalSessionPolicy> {
let hip = root.descendant("hip-collection");
let interval = hip
.and_then(|hip| hip.child("hip-report-interval"))
.map(|element| element.get_text().unwrap_or_default().into_owned());
let collect = hip
.and_then(|hip| hip.child("collect-hip-data"))
.map(|element| element.get_text().unwrap_or_default().into_owned());
let interval = parse_policy_number(interval, 3600, "hip-report-interval")?;
let collect = match collect.as_deref().map(str::trim) {
None | Some("yes") => true,
Some("no") => false,
Some(_) => bail!("Invalid portal collect-hip-data policy"),
};
InternalSessionPolicy::new(interval, collect)
}
fn parse_policy_number(value: Option<String>, default: u32, field: &str) -> anyhow::Result<u32> {
match value {
Some(value) => value
.trim()
.parse()
.map_err(|_| anyhow::anyhow!("Invalid portal {field} policy")),
None => Ok(default),
}
}
fn parse_default_browser(root: &Element) -> Option<bool> {
match root.descendant_text("default-browser")?.trim() {
"yes" => Some(true),
@@ -390,94 +313,49 @@ fn parse_connect_method(root: &Element) -> Option<String> {
.map(|s| s.to_string())
}
fn parse_internal_detection(element: &Element) -> anyhow::Result<Option<InternalHostDetection>> {
// Perform DNS lookup and compare the result with the expected hostname
fn internal_host_detect(element: &Element) -> bool {
let ip_info = [
(element.child_text("ip-address"), element.child_text("host")),
(element.child_text("ipv6-address"), element.child_text("ipv6-host")),
];
let mut targets = Vec::new();
info!("Found internal-host-detection, performing DNS lookup");
for (ip_address, host) in ip_info.iter() {
let address = ip_address.as_deref().filter(|value| !value.is_empty());
let host = host.as_deref().filter(|value| !value.is_empty());
match (address, host) {
(None, None) => {}
(Some(address), Some(host)) => targets.push((address.parse()?, host.to_owned())),
_ => bail!("Incomplete internal host detection policy"),
if let (Some(ip_address), Some(host)) = (ip_address.as_deref(), host.as_deref())
&& !ip_address.is_empty()
&& !host.is_empty()
{
match ip_address.parse::<std::net::IpAddr>() {
Ok(ip) => match lookup_addr(&ip) {
Ok(host_lookup) if host_lookup.to_lowercase() == host.to_lowercase() => {
return true;
}
Ok(host_lookup) => {
info!(
"rDNS lookup for {} returned {}, expected {}",
ip_address, host_lookup, host
);
}
Err(err) => warn!("rDNS lookup failed for {}: {}", ip_address, err),
},
Err(err) => warn!("Invalid IP address {}: {}", ip_address, err),
}
}
}
if targets.is_empty() {
Ok(None)
} else {
Ok(Some(InternalHostDetection::new(targets)?))
}
false
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn invalid_non_tunnel_policy_does_not_reject_tunnel_candidates() {
let root = parse_xml(
"<policy><hip-collection><hip-report-interval>invalid</hip-report-interval></hip-collection><internal-host-detection><ip-address>invalid</ip-address><host>internal.example</host></internal-host-detection><gateways><external><list><entry name='vpn.example'/></list></external></gateways></policy>",
);
let credential = crate::credential::PasswordCredential::new("alice", "password").into();
let config = parse_portal_config("portal.example", &credential, root, &CancellationToken::new())
.await
.unwrap();
assert!(config.internal_session_policy().is_none());
assert_eq!(config.gateways()[0].server(), "vpn.example");
assert_eq!(config.gateways()[0].kind(), crate::gateway::GatewayKind::External);
}
fn parse_xml(xml: &str) -> Element {
Element::parse(xml.as_bytes()).unwrap()
}
#[test]
fn parses_internal_maintenance_policy_with_explicit_units() {
let root = parse_xml(
"<policy><hip-collection><hip-report-interval>60</hip-report-interval><collect-hip-data>no</collect-hip-data></hip-collection><max-internal-gateway-connection-attempts>3</max-internal-gateway-connection-attempts></policy>",
);
let policy = parse_internal_session_policy(&root).unwrap();
assert_eq!(policy.hip_interval(), std::time::Duration::from_secs(60));
assert!(!policy.collect_hip_data());
assert_eq!(
parse_internal_session_policy(&parse_xml("<policy/>")).unwrap(),
InternalSessionPolicy::default()
);
}
#[test]
fn rejects_invalid_supplied_internal_policy() {
for interval in ["0", "-1", "", "4294967295", "not-a-number"] {
let root = parse_xml(&format!(
"<policy><hip-collection><hip-report-interval>{interval}</hip-report-interval></hip-collection></policy>"
));
assert!(parse_internal_session_policy(&root).is_err());
}
let root = parse_xml("<policy><hip-collection><collect-hip-data>true</collect-hip-data></hip-collection></policy>");
assert!(parse_internal_session_policy(&root).is_err());
}
#[tokio::test]
async fn accepts_existing_full_portal_fixture() {
let root = parse_xml(include_str!("../../tests/files/portal_config.xml"));
let cred = Credential::from(crate::credential::PasswordCredential::new(
"fixture-user",
"fixture-password",
));
let config = parse_portal_config("vpn.example.com", &cred, root, &CancellationToken::new())
.await
.unwrap();
assert_eq!(
config.internal_session_policy().unwrap().hip_interval(),
std::time::Duration::from_secs(3600)
);
assert!(!config.gateways().is_empty());
}
#[test]
fn parses_allow_extend_session_yes() {
let root = parse_xml("<response><allow-extend-session>yes</allow-extend-session></response>");
@@ -534,8 +412,8 @@ mod tests {
assert_eq!(parse_connect_method(&root).as_deref(), Some("on-demand"));
}
#[tokio::test]
async fn parses_csc_policy_response_as_portal_config() {
#[test]
fn parses_csc_policy_response_as_portal_config() {
let root = parse_xml(
r#"<policy>
<portal-userauthcookie>user-cookie</portal-userauthcookie>
@@ -553,9 +431,7 @@ mod tests {
);
let cred = Credential::from(crate::credential::PasswordCredential::new("alice", "secret"));
let config = parse_portal_config("vpn.example.com", &cred, root, &CancellationToken::new())
.await
.unwrap();
let config = parse_portal_config("vpn.example.com", &cred, root).unwrap();
assert_eq!(config.auth_cookie().user_auth_cookie(), "user-cookie");
assert_eq!(config.auth_cookie().prelogon_user_auth_cookie(), "prelogon-cookie");
+11 -32
View File
@@ -1,23 +1,20 @@
use std::{
net::IpAddr,
path::{Path, PathBuf},
process::Stdio,
};
use anyhow::bail;
use common::binary_paths;
use tokio::process::Command;
use tokio_util::sync::CancellationToken;
#[cfg(feature = "webview-auth")]
use crate::auth::AuthWindowTheme;
use crate::{auth::SamlAuthResult, credential::Credential, log_format::LogFormat, os_profile::OsProfile};
use super::{command_runner::run_controlled, command_traits::CommandExt};
const MAX_AUTH_RESULT_BYTES: usize = 256 * 1024;
use super::command_traits::CommandExt;
pub struct SamlAuthLauncher<'a> {
cancellation: CancellationToken,
server: &'a str,
auth_executable: Option<&'a str>,
gateway: bool,
@@ -49,7 +46,6 @@ pub struct SamlAuthLauncher<'a> {
impl<'a> SamlAuthLauncher<'a> {
pub fn new(server: &'a str) -> Self {
Self {
cancellation: CancellationToken::new(),
server,
auth_executable: None,
gateway: false,
@@ -180,11 +176,6 @@ impl<'a> SamlAuthLauncher<'a> {
self
}
pub fn cancellation(mut self, cancellation: &CancellationToken) -> Self {
self.cancellation = cancellation.clone();
self
}
/// The command line this launcher will run.
///
/// Split out from `launch` so a test can observe the argv the child actually
@@ -282,30 +273,18 @@ impl<'a> SamlAuthLauncher<'a> {
.unwrap_or_else(binary_paths::gpauth);
let auth_cmd = self.build_command(&program);
let command = auth_cmd.into_non_root()?.into_std();
let cancellation = self.cancellation;
let output = tokio::task::spawn_blocking(move || {
let check = || {
if cancellation.is_cancelled() {
Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"Authentication cancelled",
))
} else {
Ok(())
}
};
run_controlled(command, &check, MAX_AUTH_RESULT_BYTES)
})
.await?;
let output = match output {
Ok(output) => output,
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => {
return Err(crate::auth::AuthenticationCancelled.into());
let mut non_root_cmd = auth_cmd.into_non_root()?;
let child = non_root_cmd.kill_on_drop(true).stdout(Stdio::piped()).spawn();
let child = match child {
Ok(child) => child,
Err(err) => {
bail!("Failed to spawn {}: {}", program.display(), err);
}
Err(error) => return Err(error.into()),
};
let output = child.wait_with_output().await?;
let Ok(auth_result) = serde_json::from_slice::<SamlAuthResult>(&output.stdout) else {
bail!("Failed to parse auth data")
};
-315
View File
@@ -1,315 +0,0 @@
use std::{
fs, io,
os::unix::fs::{MetadataExt, PermissionsExt},
path::{Path, PathBuf},
process::{Command, Output, Stdio},
time::{Duration, Instant},
};
use super::command_runner::run_controlled;
/// Invocation control borrowed by collection; interruption must never be treated
/// as an unavailable optional product.
pub trait CollectionControl {
fn check(&self) -> io::Result<()>;
}
impl<F: Fn() -> io::Result<()>> CollectionControl for F {
fn check(&self) -> io::Result<()> {
self()
}
}
pub struct CollectionBudget {
deadline: Instant,
}
impl CollectionBudget {
pub fn new(timeout: Duration) -> Self {
Self {
deadline: Instant::now() + timeout,
}
}
}
impl CollectionControl for CollectionBudget {
fn check(&self) -> io::Result<()> {
if Instant::now() >= self.deadline {
Err(io::Error::new(
io::ErrorKind::TimedOut,
"Device information collection timed out",
))
} else {
Ok(())
}
}
}
const COMMAND_OUTPUT_LIMIT: usize = 256 * 1024;
const TOOL_DIRECTORIES: &[&str] = &[
"/usr/bin",
"/usr/sbin",
"/bin",
"/sbin",
"/usr/local/bin",
"/usr/local/sbin",
#[cfg(target_os = "linux")]
"/run/current-system/sw/bin",
];
fn tool_directories() -> Vec<PathBuf> {
let configured = std::env::var_os("GP_COMMAND_PATH").unwrap_or_default();
let mut directories: Vec<_> = std::env::split_paths(&configured)
.filter(|path| path.is_absolute())
.collect();
directories.extend(TOOL_DIRECTORIES.iter().map(PathBuf::from));
directories
}
pub struct CollectorCommands<'a> {
control: &'a dyn CollectionControl,
}
impl<'a> CollectorCommands<'a> {
pub fn new(control: &'a dyn CollectionControl) -> Self {
Self { control }
}
pub fn resolve(&self, name: &str) -> Option<PathBuf> {
resolve_in_directories(name, &tool_directories(), uzers::get_effective_uid() == 0)
}
pub fn run(&self, name: &str, args: &[&str]) -> io::Result<Option<Output>> {
self.control.check()?;
let Some(path) = self.resolve(name) else {
return Ok(None);
};
self.run_path(&path, args)
}
/// Run an installed helper with the same trust checks as system collectors.
/// Root only executes helpers protected from unprivileged modification.
pub fn run_executable(&self, path: &Path, args: &[&str]) -> io::Result<Option<Output>> {
self.control.check()?;
let Some(path) = resolve_executable(path, uzers::get_effective_uid() == 0) else {
return Ok(None);
};
self.run_path(&path, args)
}
pub fn run_path(&self, path: &Path, args: &[&str]) -> io::Result<Option<Output>> {
self.control.check()?;
let home = if uzers::get_effective_uid() == 0 {
if cfg!(target_os = "macos") {
"/var/root"
} else {
"/root"
}
} else {
"/"
};
let mut command = Command::new(path);
command
.args(args)
.env_clear()
.env("PATH", command_path(uzers::get_effective_uid() == 0)?)
.env("LC_ALL", "C")
.env("HOME", home)
.current_dir("/")
.stderr(Stdio::null());
match run_controlled(command, self.control, COMMAND_OUTPUT_LIMIT) {
Ok(output) => Ok(Some(output)),
Err(error) if matches!(error.kind(), io::ErrorKind::NotFound | io::ErrorKind::PermissionDenied) => Ok(None),
Err(error) => Err(error),
}
}
}
fn resolve_in_directories(name: &str, directories: &[PathBuf], require_root: bool) -> Option<PathBuf> {
directories.iter().find_map(|directory| {
let directory = fs::canonicalize(directory).ok()?;
if require_root && !root_owned_path(&directory) {
return None;
}
resolve_executable(&directory.join(name), require_root)
})
}
fn resolve_executable(path: &Path, require_root: bool) -> Option<PathBuf> {
let resolved = fs::canonicalize(path).ok()?;
let metadata = fs::metadata(&resolved).ok()?;
if metadata.is_file() && metadata.permissions().mode() & 0o111 != 0 && (!require_root || root_owned_path(&resolved)) {
Some(resolved)
} else {
None
}
}
/// Known command directories, canonicalized and restricted to trusted root
/// ownership when used for privileged execution.
pub fn command_path(require_root: bool) -> io::Result<std::ffi::OsString> {
let configured = tool_directories();
let directories = configured.iter().filter_map(|directory| {
let resolved = fs::canonicalize(directory).ok()?;
if resolved.is_dir() && (!require_root || root_owned_path(&resolved)) {
Some(resolved)
} else {
None
}
});
std::env::join_paths(directories).map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))
}
fn root_owned_path(path: &Path) -> bool {
path.ancestors().all(|part| {
fs::symlink_metadata(part).is_ok_and(|metadata| {
let mode = metadata.permissions().mode();
let writable = mode & 0o022 != 0;
// A root-owned sticky directory protects each root-owned descendant
// from replacement, including entries in the Nix store.
let protected_ancestor = part != path && metadata.is_dir() && mode & 0o1000 != 0;
metadata.uid() == 0 && (!writable || protected_ancestor) && !metadata.file_type().is_symlink()
})
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn root_owned_sticky_directories_protect_collectors_without_trusting_writable_files() {
// CI runs Rust tests as root; an unprivileged process cannot create these fixtures.
if uzers::get_effective_uid() != 0 {
return;
}
let directory = tempfile::tempdir().unwrap();
let tool = directory.path().join("collector");
fs::write(&tool, "#!/bin/sh\nexit 0\n").unwrap();
fs::set_permissions(&tool, fs::Permissions::from_mode(0o755)).unwrap();
fs::set_permissions(directory.path(), fs::Permissions::from_mode(0o1775)).unwrap();
assert_eq!(resolve_executable(&tool, true), Some(fs::canonicalize(&tool).unwrap()));
// A PATH directory must itself reject unprivileged additions, even with the sticky bit.
assert!(!root_owned_path(directory.path()));
assert!(resolve_in_directories("collector", &[directory.path().to_owned()], true).is_none());
let bin = directory.path().join("bin");
fs::create_dir(&bin).unwrap();
fs::set_permissions(&bin, fs::Permissions::from_mode(0o755)).unwrap();
fs::copy(&tool, bin.join("collector")).unwrap();
assert!(resolve_in_directories("collector", &[bin], true).is_some());
fs::set_permissions(directory.path(), fs::Permissions::from_mode(0o775)).unwrap();
assert!(resolve_executable(&tool, true).is_none());
fs::set_permissions(directory.path(), fs::Permissions::from_mode(0o1777)).unwrap();
assert!(resolve_executable(&tool, true).is_some());
fs::set_permissions(&tool, fs::Permissions::from_mode(0o1775)).unwrap();
assert!(resolve_executable(&tool, true).is_none());
fs::set_permissions(&tool, fs::Permissions::from_mode(0o755)).unwrap();
std::os::unix::fs::chown(&tool, Some(1), None).unwrap();
assert!(resolve_executable(&tool, true).is_none());
std::os::unix::fs::chown(&tool, Some(0), None).unwrap();
std::os::unix::fs::chown(directory.path(), Some(1), None).unwrap();
assert!(resolve_executable(&tool, true).is_none());
}
#[test]
fn configured_directories_resolve_tools_without_using_the_process_path() {
let dir = tempfile::tempdir().unwrap();
let tool = dir.path().join("configured-tool");
fs::write(&tool, "#!/bin/sh\nexit 0\n").unwrap();
fs::set_permissions(&tool, fs::Permissions::from_mode(0o755)).unwrap();
assert_eq!(
resolve_in_directories("configured-tool", &[dir.path().to_owned()], false),
Some(fs::canonicalize(&tool).unwrap())
);
fs::set_permissions(&tool, fs::Permissions::from_mode(0o777)).unwrap();
assert!(resolve_in_directories("configured-tool", &[dir.path().to_owned()], true).is_none());
}
#[test]
fn root_command_path_contains_only_trusted_canonical_directories() {
let path = command_path(true).unwrap();
let directories: Vec<_> = std::env::split_paths(&path).collect();
assert!(!directories.is_empty());
for directory in directories {
assert!(directory.is_dir());
assert!(root_owned_path(&directory));
assert_eq!(directory, fs::canonicalize(&directory).unwrap());
}
}
#[test]
fn executable_resolution_returns_target_not_mutable_symlink() {
let dir = tempfile::tempdir().unwrap();
let link = dir.path().join("tool");
std::os::unix::fs::symlink("/bin/sh", &link).unwrap();
let resolved = resolve_executable(&link, false).unwrap();
fs::remove_file(&link).unwrap();
std::os::unix::fs::symlink("/bin/echo", &link).unwrap();
assert_eq!(resolved, fs::canonicalize("/bin/sh").unwrap());
assert_ne!(resolved, fs::canonicalize(&link).unwrap());
}
#[test]
fn cancellation_stops_running_collector() {
let started = Instant::now();
let control = || {
if started.elapsed() >= Duration::from_millis(100) {
Err(io::Error::new(io::ErrorKind::Interrupted, "cancelled"))
} else {
Ok(())
}
};
let error = CollectorCommands::new(&control)
.run_path(Path::new("/bin/sh"), &["-c", "sleep 30 & wait"])
.unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::Interrupted);
assert!(started.elapsed() < Duration::from_secs(2));
}
#[test]
fn collector_has_private_environment_and_cwd() {
let budget = CollectionBudget::new(Duration::from_secs(2));
let output = CollectorCommands::new(&budget)
.run_path(
Path::new("/bin/sh"),
&[
"-c",
"printf '%s|%s|%s' \"$LC_ALL\" \"$PWD\" \"${SENTINEL_OUTPUT_JSON-unset}\"",
],
)
.unwrap()
.unwrap();
assert!(output.status.success());
assert_eq!(String::from_utf8(output.stdout).unwrap(), "C|/|unset");
}
#[test]
fn deadline_stops_collector_instead_of_hanging() {
let budget = CollectionBudget::new(Duration::from_millis(100));
let started = Instant::now();
let error = CollectorCommands::new(&budget)
.run_path(Path::new("/bin/sh"), &["-c", "sleep 30"])
.unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::TimedOut);
assert!(started.elapsed() < Duration::from_secs(2));
}
#[test]
fn collector_output_is_bounded() {
let budget = CollectionBudget::new(Duration::from_secs(2));
let error = CollectorCommands::new(&budget)
.run_path(Path::new("/bin/sh"), &["-c", "yes x"])
.unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::InvalidData);
}
#[test]
fn cancellation_is_not_an_optional_missing_product() {
let control = || Err(io::Error::new(io::ErrorKind::Interrupted, "cancelled"));
let error = CollectorCommands::new(&control).run("not-installed", &[]).unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::Interrupted);
}
}
@@ -1,84 +0,0 @@
use std::{
io::{self, Read},
os::unix::process::CommandExt,
process::{Child, Command, Output, Stdio},
thread,
time::Duration,
};
use nix::{
fcntl::{FcntlArg, OFlag, fcntl},
sys::signal::{Signal, killpg},
unistd::Pid,
};
use super::collection::CollectionControl;
/// Execute an already configured command. Environment, identity and executable
/// trust belong to its caller. This worker owns the process group until reaped;
/// its asynchronous caller must cancel and await it instead of dropping it.
pub(crate) fn run_controlled(
mut command: Command,
control: &dyn CollectionControl,
output_limit: usize,
) -> io::Result<Output> {
control.check()?;
let child = command
.stdin(Stdio::null())
.stdout(Stdio::piped())
.process_group(0)
.spawn()?;
let mut child = ControlledChild(child);
let mut stdout = child.0.stdout.take().expect("controlled stdout was piped");
let flags = fcntl(&stdout, FcntlArg::F_GETFL).map_err(io::Error::from)?;
fcntl(
&stdout,
FcntlArg::F_SETFL(OFlag::from_bits_truncate(flags) | OFlag::O_NONBLOCK),
)
.map_err(io::Error::from)?;
let mut output = Vec::new();
let mut buffer = [0u8; 8192];
let mut eof = false;
let mut status = None;
loop {
control.check()?;
if !eof {
match stdout.read(&mut buffer) {
Ok(0) => eof = true,
Ok(length) => {
if length > output_limit.saturating_sub(output.len()) {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"Command output exceeds its limit",
));
}
output.extend_from_slice(&buffer[..length]);
continue;
}
Err(error) if matches!(error.kind(), io::ErrorKind::WouldBlock | io::ErrorKind::Interrupted) => {}
Err(error) => return Err(error),
}
}
if status.is_none() {
status = child.0.try_wait()?;
}
if eof && let Some(status) = status {
return Ok(Output {
status,
stdout: output,
stderr: Vec::new(),
});
}
thread::sleep(Duration::from_millis(10));
}
}
struct ControlledChild(Child);
impl Drop for ControlledChild {
fn drop(&mut self) {
// Reap the direct child and stop helpers retaining stdout after it exits.
let _ = killpg(Pid::from_raw(self.0.id() as i32), Signal::SIGKILL);
let _ = self.0.wait();
}
}
@@ -1,172 +0,0 @@
use std::{
collections::HashMap,
fs::{File, OpenOptions},
path::Path,
process::{ExitStatus, Stdio},
sync::Arc,
};
use anyhow::{Context, ensure};
use common::binary_paths;
use tokio::{
io::{AsyncRead, AsyncReadExt, AsyncWriteExt},
process::Command,
};
use zeroize::Zeroizing;
use super::{CommandExt, gui_launcher::GuiLauncher};
use crate::service::transport::{MAX_CREDENTIAL_FRAME, SessionCredential};
/// Owns the desktop GUI and its privileged service without leaving the desktop session.
pub struct DesktopLauncher<'a> {
version: &'a str,
minimized: bool,
log_file: Option<String>,
}
impl<'a> DesktopLauncher<'a> {
pub fn new(version: &'a str) -> Self {
Self {
version,
minimized: false,
log_file: None,
}
}
pub fn minimized(mut self, minimized: bool) -> Self {
self.minimized = minimized;
self
}
pub fn log_file(mut self, log_file: &str) -> Self {
self.log_file = Some(log_file.to_owned());
self
}
pub async fn launch(&self) -> anyhow::Result<ExitStatus> {
ensure!(
uzers::get_effective_uid() != 0,
"The desktop launcher must not run as root"
);
let mut command = Command::new_pkexec(binary_paths::gpservice());
command
.arg("--desktop-credentials")
.stdin(Stdio::piped())
.stdout(Stdio::piped());
if let Some(path) = &self.log_file {
command.stderr(Stdio::from(create_log_file(Path::new(path))?));
}
let mut service = command.spawn().context("Failed to start the privileged service")?;
let mut input = service.stdin.take().context("Service input pipe is unavailable")?;
let mut output = service
.stdout
.take()
.context("Service credential pipe is unavailable")?;
let mut received_credential = false;
let mut cancelled = false;
let result = tokio::select! {
_ = crate::utils::shutdown_signal() => { cancelled = true; Ok(()) },
result = async {
let mut minimized = self.minimized;
loop {
let credential = read_credential(&mut output).await?;
let Some(credential) = credential else { return Ok(()); };
received_credential = true;
ensure!(credential.product_version() == self.version, "Service product version mismatch");
let mut envs: HashMap<String, String> = std::env::vars().collect();
if let Some(path) = &self.log_file {
envs.insert("GP_LOG_FILE".into(), path.clone());
}
let launcher = GuiLauncher::new(self.version, Arc::new(credential)).envs(envs).minimized(minimized);
let mut unexpected = [0];
tokio::select! {
result = launcher.launch() => { result?; }
status = service.wait() => { anyhow::bail!("The privileged service exited while the GUI was running: {}", status?); }
result = output.read(&mut unexpected) => {
ensure!(result? == 0, "Unexpected service credential data while the GUI is running");
anyhow::bail!("The privileged service closed its credential channel");
}
}
input.write_all(&[0]).await?;
minimized = false;
}
} => result,
};
// EOF lets the service revoke the credential and disconnect the VPN gracefully.
drop(input);
if cancelled && !received_credential {
// pkexec is still user-owned during authorization. After elevation, EOF owns shutdown.
if let Err(error) = service.start_kill()
&& error.kind() != std::io::ErrorKind::PermissionDenied
{
return Err(error.into());
}
}
let status = service.wait().await?;
result?;
ensure!(
cancelled || status.success(),
"The privileged service exited with {status}"
);
Ok(status)
}
}
fn create_log_file(path: &Path) -> std::io::Result<File> {
// Start a fresh desktop session, then let both processes append without overwriting each other.
File::create(path)?;
OpenOptions::new().append(true).open(path)
}
async fn read_credential(reader: &mut (impl AsyncRead + Unpin)) -> anyhow::Result<Option<SessionCredential>> {
let mut header = [0; 2];
if reader.read(&mut header[..1]).await? == 0 {
return Ok(None);
}
reader.read_exact(&mut header[1..]).await?;
let length = usize::from(u16::from_be_bytes(header));
ensure!(
length != 0 && length + 2 <= MAX_CREDENTIAL_FRAME,
"Invalid service credential length"
);
let mut frame = Zeroizing::new(vec![0; length + 2]);
frame[..2].copy_from_slice(&header);
reader.read_exact(&mut frame[2..]).await?;
Ok(Some(SessionCredential::decode_frame(&frame)?))
}
#[cfg(test)]
mod tests {
use std::io::Write;
use super::*;
#[test]
fn desktop_log_starts_fresh_and_service_writes_preserve_gui_logs() {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.path().join("desktop.log");
std::fs::write(&path, "previous session\n").unwrap();
let mut service = create_log_file(&path).unwrap();
writeln!(service, "[gpservice] started").unwrap();
let mut gui = OpenOptions::new().append(true).open(&path).unwrap();
writeln!(gui, "[gpgui] initialized").unwrap();
writeln!(service, "[gpservice] connected").unwrap();
assert_eq!(
std::fs::read_to_string(&path).unwrap(),
"[gpservice] started\n[gpgui] initialized\n[gpservice] connected\n"
);
}
#[tokio::test]
async fn credential_channel_distinguishes_clean_close_from_truncated_or_oversized_frames() {
assert!(read_credential(&mut &[][..]).await.unwrap().is_none());
assert!(read_credential(&mut &[0][..]).await.is_err());
assert!(read_credential(&mut &[0, 0][..]).await.is_err());
assert!(read_credential(&mut &[255, 255][..]).await.is_err());
let credential = SessionCredential::generate(uuid::Uuid::new_v4(), "test").unwrap();
let frame = credential.encode_frame().unwrap();
let decoded = read_credential(&mut frame.as_slice()).await.unwrap().unwrap();
assert_eq!(decoded.session_id(), credential.session_id());
}
}
@@ -5,7 +5,7 @@ use common::binary_paths;
use log::info;
use tokio::{io::AsyncWriteExt, process::Command};
use crate::service::transport::SessionCredential;
use crate::{process::command_traits::CommandExt, service::transport::SessionCredential};
pub struct GuiHelperLauncher<'a> {
program: PathBuf,
@@ -49,11 +49,8 @@ impl<'a> GuiHelperLauncher<'a> {
}
info!("Launching gpgui-helper");
anyhow::ensure!(
uzers::get_effective_uid() != 0,
"The desktop GUI must not be launched by root"
);
let child = cmd.kill_on_drop(true).stdin(Stdio::piped()).spawn();
let mut non_root_cmd = cmd.into_non_root()?;
let child = non_root_cmd.kill_on_drop(true).stdin(Stdio::piped()).spawn();
let mut child = match child {
Ok(child) => child,
Err(err) => bail!("Failed to spawn {}: {}", self.program.display(), err),
+6 -41
View File
@@ -1,18 +1,19 @@
use std::{
collections::HashMap,
fs::OpenOptions,
path::{Path, PathBuf},
process::{ExitStatus, Stdio},
sync::Arc,
};
use anyhow::{Context, bail};
use anyhow::bail;
use common::binary_paths;
use log::info;
use tokio::{io::AsyncWriteExt, process::Command};
use crate::{process::gui_helper_launcher::GuiHelperLauncher, service::transport::SessionCredential};
use super::command_traits::CommandExt;
pub struct GuiLauncher<'a> {
version: &'a str,
programs: Vec<PathBuf>,
@@ -51,10 +52,6 @@ impl<'a> GuiLauncher<'a> {
}
pub async fn launch(&self) -> anyhow::Result<ExitStatus> {
anyhow::ensure!(
uzers::get_effective_uid() != 0,
"The desktop GUI must not be launched by root"
);
if let Some(program) = self.find_compatible_program().await {
return self.launch_program(&program).await;
}
@@ -88,18 +85,6 @@ impl<'a> GuiLauncher<'a> {
cmd.envs(envs);
}
let log_file = match &self.envs {
Some(envs) => envs.get("GP_LOG_FILE").map(PathBuf::from),
None => std::env::var_os("GP_LOG_FILE").map(PathBuf::from),
};
if let Some(path) = log_file {
let file = OpenOptions::new()
.append(true)
.open(&path)
.with_context(|| format!("Failed to open GUI log file: {}", path.display()))?;
cmd.stderr(Stdio::from(file));
}
cmd.arg("--service-credential-on-stdin");
if self.minimized {
@@ -107,7 +92,8 @@ impl<'a> GuiLauncher<'a> {
}
info!("Launching gpgui");
let child = cmd.kill_on_drop(true).stdin(Stdio::piped()).spawn();
let mut non_root_cmd = cmd.into_non_root()?;
let child = non_root_cmd.kill_on_drop(true).stdin(Stdio::piped()).spawn();
let mut child = match child {
Ok(child) => child,
Err(err) => bail!("Failed to spawn {}: {}", program.display(), err),
@@ -133,7 +119,7 @@ impl<'a> GuiLauncher<'a> {
cmd.envs(envs);
}
cmd.arg("--version");
let output = cmd.output().await?;
let output = cmd.into_non_root()?.output().await?;
if !output.status.success() {
bail!("Version command exited with {}", output.status);
}
@@ -197,27 +183,6 @@ mod tests {
}
}
#[tokio::test]
async fn captures_gui_logs_in_the_desktop_log_file_across_restarts() {
let dir = TempDir::new().unwrap();
let log_file = dir.path().join("desktop.log");
fs::write(&log_file, "[gpservice] started\n").unwrap();
let program = dir.path().join("gui");
fs::write(&program, "#!/bin/sh\nprintf '[gpgui] initialized\\n' >&2\n").unwrap();
fs::set_permissions(&program, fs::Permissions::from_mode(0o755)).unwrap();
let launcher = launcher(VERSION, vec![]).envs(HashMap::from([(
"GP_LOG_FILE".to_owned(),
log_file.to_str().unwrap().to_owned(),
)]));
assert!(launcher.launch_program(&program).await.unwrap().success());
assert!(launcher.launch_program(&program).await.unwrap().success());
assert_eq!(
fs::read_to_string(log_file).unwrap(),
"[gpservice] started\n[gpgui] initialized\n[gpgui] initialized\n"
);
}
#[tokio::test]
async fn prefers_the_first_compatible_program() {
let dir = TempDir::new().unwrap();
+96
View File
@@ -0,0 +1,96 @@
use std::process::Stdio;
use anyhow::bail;
use tokio::process::Command;
pub struct HipLauncher<'a> {
program: &'a str,
cookie: Option<&'a str>,
client_ip: Option<&'a str>,
md5: Option<&'a str>,
client_os: Option<&'a str>,
client_version: Option<&'a str>,
}
impl<'a> HipLauncher<'a> {
pub fn new(program: &'a str) -> Self {
Self {
program,
cookie: None,
client_ip: None,
md5: None,
client_os: None,
client_version: None,
}
}
pub fn cookie(mut self, cookie: &'a str) -> Self {
self.cookie = Some(cookie);
self
}
pub fn client_ip(mut self, client_ip: &'a str) -> Self {
self.client_ip = Some(client_ip);
self
}
pub fn md5(mut self, md5: &'a str) -> Self {
self.md5 = Some(md5);
self
}
pub fn client_os(mut self, client_os: &'a str) -> Self {
self.client_os = Some(client_os);
self
}
pub fn client_version(mut self, client_version: Option<&'a str>) -> Self {
self.client_version = client_version;
self
}
pub async fn launch(&self) -> anyhow::Result<String> {
let mut cmd = Command::new(self.program);
if let Some(cookie) = self.cookie {
cmd.arg("--cookie").arg(cookie);
}
if let Some(client_ip) = self.client_ip {
cmd.arg("--client-ip").arg(client_ip);
}
if let Some(md5) = self.md5 {
cmd.arg("--md5").arg(md5);
}
if let Some(client_os) = self.client_os {
cmd.arg("--client-os").arg(client_os);
}
if let Some(client_version) = self.client_version {
cmd.env("APP_VERSION", client_version);
}
let child = cmd.kill_on_drop(true).stdout(Stdio::piped()).spawn();
let child = match child {
Ok(child) => child,
Err(err) => bail!("Failed to spawn {}: {}", self.program, err),
};
let output = child.wait_with_output().await?;
if let Some(exit_status) = output.status.code() {
if exit_status != 0 {
bail!("HIP report generation failed with exit code {}", exit_status);
}
let report = String::from_utf8(output.stdout)?;
Ok(report)
} else {
bail!("HIP report generation failed");
}
}
}
+2 -4
View File
@@ -1,4 +1,3 @@
mod command_runner;
mod command_traits;
mod desktop_session_env;
pub(crate) mod gui_helper_launcher;
@@ -6,8 +5,7 @@ pub(crate) mod gui_helper_launcher;
pub use command_traits::CommandExt;
pub mod auth_launcher;
pub mod desktop_launcher;
pub mod gui_launcher;
pub mod hip_launcher;
pub mod service_launcher;
pub mod users;
pub mod collection;
@@ -0,0 +1,82 @@
use std::{
fs::File,
path::PathBuf,
process::{ExitStatus, Stdio},
};
use common::binary_paths;
use tokio::process::Command;
use super::command_traits::CommandExt;
pub struct ServiceLauncher<'a> {
program: PathBuf,
minimized: bool,
env_file: Option<String>,
log_file: Option<String>,
verbose: Option<&'a str>,
}
impl Default for ServiceLauncher<'_> {
fn default() -> Self {
Self::new()
}
}
impl<'a> ServiceLauncher<'a> {
pub fn new() -> Self {
Self {
program: binary_paths::gpservice(),
minimized: false,
env_file: None,
log_file: None,
verbose: None,
}
}
pub fn minimized(mut self, minimized: bool) -> Self {
self.minimized = minimized;
self
}
pub fn env_file(mut self, env_file: &str) -> Self {
self.env_file = Some(env_file.to_string());
self
}
pub fn log_file(mut self, log_file: &str) -> Self {
self.log_file = Some(log_file.to_string());
self
}
pub fn verbose(mut self, verbose: Option<&'a str>) -> Self {
self.verbose = verbose;
self
}
pub async fn launch(&self) -> anyhow::Result<ExitStatus> {
let mut cmd = Command::new_pkexec(&self.program);
if self.minimized {
cmd.arg("--minimized");
}
if let Some(env_file) = &self.env_file {
cmd.arg("--env-file").arg(env_file);
}
if let Some(verbose) = self.verbose {
cmd.arg(verbose);
}
if let Some(log_file) = &self.log_file {
let log_file = File::create(log_file)?;
let stdio = Stdio::from(log_file);
cmd.stderr(stdio);
}
let exit_status = cmd.kill_on_drop(true).spawn()?.wait().await?;
Ok(exit_status)
}
}
+48 -100
View File
@@ -5,37 +5,14 @@ use specta::Type;
use zeroize::Zeroize;
use crate::{
hip::HipSource,
os_profile::{ClientOs, HostIdentity, OsProfile},
session::ConnectionPlan,
gateway::Gateway,
os_profile::{ClientOs, OsProfile},
};
use super::vpn_state::ConnectInfo;
pub const MAX_CLIENT_IDENTITY_DATA: usize = 32 * 1024;
#[derive(Debug, Deserialize, Serialize)]
pub struct StoreEditedHipReportChunkRequest {
pub upload_id: Option<String>,
pub offset: usize,
pub xml: String,
pub complete: bool,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct PreviewHipReportRequest {
pub source: HipSource,
pub client_os: ClientOs,
pub client_version: String,
pub host_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ReadHipPreviewChunkRequest {
pub preview_id: String,
pub offset: usize,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct LaunchGuiRequest {
user: String,
@@ -58,9 +35,8 @@ impl LaunchGuiRequest {
#[derive(Deserialize, Serialize, Type, Clone)]
pub struct ConnectArgs {
cookie: String,
vpnc_script: Option<String>,
host_identity: Option<HostIdentity>,
ignore_tls_errors: bool,
user_agent: Option<String>,
os: Option<ClientOs>,
@@ -74,7 +50,9 @@ pub struct ConnectArgs {
sslkey_data: Option<String>,
key_password: Option<String>,
hip_source: HipSource,
hip: bool,
csd_uid: u32,
csd_wrapper: Option<String>,
reconnect_timeout: u32,
mtu: u32,
@@ -88,11 +66,10 @@ pub struct ConnectArgs {
}
impl ConnectArgs {
fn new() -> Self {
pub fn new(cookie: String) -> Self {
Self {
cookie,
vpnc_script: None,
host_identity: None,
ignore_tls_errors: false,
user_agent: None,
os: None,
os_version: None,
@@ -103,7 +80,9 @@ impl ConnectArgs {
certificate_data: None,
sslkey_data: None,
key_password: None,
hip_source: HipSource::Disabled,
hip: false,
csd_uid: 0,
csd_wrapper: None,
reconnect_timeout: 300,
mtu: 0,
disable_ipv6: false,
@@ -115,12 +94,8 @@ impl ConnectArgs {
}
}
pub fn host_identity(&self) -> Option<&HostIdentity> {
self.host_identity.as_ref()
}
pub fn ignore_tls_errors(&self) -> bool {
self.ignore_tls_errors
pub fn cookie(&self) -> &str {
&self.cookie
}
pub fn vpnc_script(&self) -> Option<String> {
@@ -179,8 +154,16 @@ impl ConnectArgs {
self.key_password.clone()
}
pub fn hip_source(&self) -> &HipSource {
&self.hip_source
pub fn hip(&self) -> bool {
self.hip
}
pub fn csd_uid(&self) -> u32 {
self.csd_uid
}
pub fn csd_wrapper(&self) -> Option<String> {
self.csd_wrapper.clone()
}
pub fn reconnect_timeout(&self) -> u32 {
@@ -219,6 +202,7 @@ impl ConnectArgs {
impl fmt::Debug for ConnectArgs {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ConnectArgs")
.field("cookie", &"<redacted>")
.field("vpnc_script", &self.vpnc_script)
.field(
"client_auth_path",
@@ -228,7 +212,9 @@ impl fmt::Debug for ConnectArgs {
"client_auth_data",
&(self.certificate_data.is_some() || self.sslkey_data.is_some()),
)
.field("hip_source", &self.hip_source)
.field("hip", &self.hip)
.field("csd_uid", &self.csd_uid)
.field("csd_wrapper", &self.csd_wrapper)
.field("reconnect_timeout", &self.reconnect_timeout)
.field("mtu", &self.mtu)
.field("disable_ipv6", &self.disable_ipv6)
@@ -240,6 +226,7 @@ impl fmt::Debug for ConnectArgs {
impl Drop for ConnectArgs {
fn drop(&mut self) {
self.cookie.zeroize();
self.key_password.zeroize();
self.certificate_data.zeroize();
self.sslkey_data.zeroize();
@@ -249,16 +236,14 @@ impl Drop for ConnectArgs {
#[derive(Debug, Deserialize, Serialize, Type, Clone)]
pub struct ConnectRequest {
info: ConnectInfo,
plan: ConnectionPlan,
args: ConnectArgs,
}
impl ConnectRequest {
pub fn new(info: ConnectInfo, plan: ConnectionPlan) -> Self {
pub fn new(info: ConnectInfo, cookie: String) -> Self {
Self {
info,
plan,
args: ConnectArgs::new(),
args: ConnectArgs::new(cookie),
}
}
@@ -267,13 +252,22 @@ impl ConnectRequest {
self
}
pub fn with_hip_source(mut self, hip_source: HipSource) -> Self {
self.args.hip_source = hip_source;
pub fn with_hip(mut self, hip: bool) -> Self {
self.args.hip = hip;
self
}
pub fn with_csd_uid(mut self, csd_uid: u32) -> Self {
self.args.csd_uid = csd_uid;
self
}
pub fn with_csd_wrapper<T: Into<Option<String>>>(mut self, csd_wrapper: T) -> Self {
self.args.csd_wrapper = csd_wrapper.into();
self
}
pub fn with_os_profile(mut self, profile: &OsProfile) -> Self {
self.args.host_identity = Some(profile.host_identity().clone());
self.args.os = Some(profile.client_os());
self.args.os_version = Some(profile.os_version().to_string());
self.args.client_version = Some(profile.client_version().to_string());
@@ -282,11 +276,6 @@ impl ConnectRequest {
self
}
pub fn with_ignore_tls_errors(mut self, ignore_tls_errors: bool) -> Self {
self.args.ignore_tls_errors = ignore_tls_errors;
self
}
pub fn with_certificate<T: Into<Option<String>>>(mut self, certificate: T) -> Self {
self.args.certificate = certificate.into();
self
@@ -352,8 +341,8 @@ impl ConnectRequest {
self
}
pub fn plan(&self) -> &ConnectionPlan {
&self.plan
pub fn gateway(&self) -> &Gateway {
self.info.gateway()
}
pub fn info(&self) -> &ConnectInfo {
@@ -382,12 +371,6 @@ pub struct UpdateLogLevelRequest(pub String);
pub enum WsRequest {
Connect(Box<ConnectRequest>),
Disconnect(DisconnectRequest),
StopNonTunnelAttachment { connection_id: uuid::Uuid },
StoreEditedHipReportChunk(StoreEditedHipReportChunkRequest),
PreviewHipReport(PreviewHipReportRequest),
GetHipApprovalStatus { approval_id: String },
ReadHipPreviewChunk(ReadHipPreviewChunkRequest),
GetLastSubmittedHipReport,
UpdateLogLevel(UpdateLogLevelRequest),
RestartGui,
UpdateGui(UpdateGuiRequest),
@@ -406,52 +389,17 @@ mod tests {
use super::*;
use crate::os_profile::OsProfileBuilder;
use crate::{
gateway::Gateway,
session::{AuthenticatedGateway, GatewayAuthentication, InternalSessionPolicy},
};
fn test_request(info: ConnectInfo) -> ConnectRequest {
let plan = ConnectionPlan::new(
vec![AuthenticatedGateway {
gateway: info.gateway().clone(),
binding: Some(crate::session::network::test_binding()),
authentication: GatewayAuthentication::new("authcookie=secret-cookie&user=user".into(), "tunnel".into())
.unwrap(),
}],
vec![],
InternalSessionPolicy::default(),
)
.unwrap();
ConnectRequest::new(info, plan)
}
fn test_connect_info() -> ConnectInfo {
let gateway = Gateway::new("Gateway".to_string(), "vpn.example.com".to_string());
ConnectInfo::new("portal.example.com".to_string(), gateway.clone(), vec![gateway])
}
#[test]
fn connect_request_round_trips_a_validated_plan_and_rejects_cookie_only_wire_input() {
let request = test_request(test_connect_info());
let mut value = serde_json::to_value(&request).unwrap();
assert!(value["args"].get("cookie").is_none());
let decoded: ConnectRequest = serde_json::from_value(value.clone()).unwrap();
assert_eq!(decoded.plan().members().len(), 1);
assert_eq!(decoded.plan().members()[0].authentication.connection_type(), "tunnel");
value["plan"]["members"] = json!([]);
assert!(serde_json::from_value::<ConnectRequest>(value).is_err());
let mut legacy = serde_json::to_value(&request).unwrap();
legacy.as_object_mut().unwrap().remove("plan");
legacy["args"]["cookie"] = json!("authcookie=secret-cookie&user=user");
assert!(serde_json::from_value::<ConnectRequest>(legacy).is_err());
}
#[test]
fn connect_request_serializes_allow_extend_session() {
let gateway = Gateway::new("Gateway".to_string(), "vpn.example.com".to_string());
let info = ConnectInfo::new("portal.example.com".to_string(), gateway.clone(), vec![gateway]);
let req = test_request(info).with_allow_extend_session(true);
let req = ConnectRequest::new(info, "authcookie=AUTH".to_string()).with_allow_extend_session(true);
let value = serde_json::to_value(req).unwrap();
assert_eq!(value["args"]["allowExtendSession"], json!(true));
@@ -461,7 +409,7 @@ mod tests {
fn with_os_profile_sets_user_agent_from_profile() {
let profile = OsProfileBuilder::new(ClientOs::Linux).client_version("6.0.0").build();
let req = test_request(test_connect_info()).with_os_profile(&profile);
let req = ConnectRequest::new(test_connect_info(), "cookie".to_string()).with_os_profile(&profile);
assert_eq!(req.args().user_agent(), Some(profile.user_agent().to_string()));
}
@@ -470,7 +418,7 @@ mod tests {
fn with_os_profile_sets_host_id_from_profile_runtime_identity() {
let profile = OsProfileBuilder::new(ClientOs::Linux).build();
let req = test_request(test_connect_info()).with_os_profile(&profile);
let req = ConnectRequest::new(test_connect_info(), "cookie".to_string()).with_os_profile(&profile);
assert_eq!(
req.args().host_id(),
@@ -480,7 +428,7 @@ mod tests {
#[test]
fn client_identity_data_round_trips_without_debug_disclosure() {
let req = test_request(test_connect_info())
let req = ConnectRequest::new(test_connect_info(), "secret-cookie".to_string())
.with_certificate_data(Some(b"certificate".to_vec()))
.with_sslkey_data(Some(b"private-key".to_vec()));
let encoded = serde_json::to_vec(&req).unwrap();
@@ -5,7 +5,6 @@ use serde::{Deserialize, Serialize};
use uuid::Uuid;
use zeroize::Zeroizing;
use crate::device_anchor::DeviceAnchor;
use crate::utils::base64;
use super::{MAX_CREDENTIAL_FRAME, MAX_PRODUCT_VERSION, TransportError};
@@ -15,7 +14,6 @@ pub struct SessionCredential {
session_id: Uuid,
secret: Zeroizing<[u8; 32]>,
product_version: String,
device_anchor: Option<DeviceAnchor>,
}
impl SessionCredential {
@@ -32,7 +30,6 @@ impl SessionCredential {
session_id: Uuid::new_v4(),
secret,
product_version: product_version.to_owned(),
device_anchor: None,
})
}
@@ -52,18 +49,6 @@ impl SessionCredential {
&self.product_version
}
pub fn with_device_anchor(mut self, anchor: DeviceAnchor) -> Result<Self, TransportError> {
if !anchor.validate() {
return Err(TransportError::InvalidCredential);
}
self.device_anchor = Some(anchor);
Ok(self)
}
pub fn device_anchor(&self) -> Option<&DeviceAnchor> {
self.device_anchor.as_ref()
}
pub fn encode_frame(&self) -> Result<Zeroizing<Vec<u8>>, TransportError> {
let encoded_secret = Zeroizing::new(base64::encode(self.secret()));
let dto = CredentialDtoRef {
@@ -71,7 +56,6 @@ impl SessionCredential {
session_id: self.session_id,
secret: encoded_secret.as_str(),
product_version: &self.product_version,
device_anchor: self.device_anchor.as_ref(),
};
let payload = Zeroizing::new(serde_json::to_vec(&dto)?);
@@ -101,12 +85,8 @@ impl SessionCredential {
session_id,
secret,
product_version,
device_anchor,
} = dto;
let encoded_secret = secret;
if device_anchor.as_ref().is_some_and(|anchor| !anchor.validate()) {
return Err(TransportError::InvalidCredential);
}
if product_version.is_empty() || product_version.len() > MAX_PRODUCT_VERSION {
return Err(TransportError::InvalidCredential);
}
@@ -124,7 +104,6 @@ impl SessionCredential {
session_id,
secret,
product_version,
device_anchor,
})
}
}
@@ -147,7 +126,6 @@ struct CredentialDtoRef<'a> {
session_id: Uuid,
secret: &'a str,
product_version: &'a str,
device_anchor: Option<&'a DeviceAnchor>,
}
#[derive(Deserialize)]
@@ -157,7 +135,6 @@ struct CredentialDto {
session_id: Uuid,
secret: Zeroizing<String>,
product_version: String,
device_anchor: Option<DeviceAnchor>,
}
#[cfg(test)]
@@ -184,40 +161,4 @@ mod tests {
assert!(SessionCredential::decode_frame(&[0, 2, b'{']).is_err());
assert!(SessionCredential::decode_frame(&vec![0; MAX_CREDENTIAL_FRAME + 1]).is_err());
}
#[test]
fn credential_round_trips_a_validated_device_anchor() {
let anchor = DeviceAnchor {
hardware_id: general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]),
source: crate::device_anchor::AnchorSource::UnixMac,
};
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5")
.unwrap()
.with_device_anchor(anchor.clone())
.unwrap();
let frame = credential.encode_frame().unwrap();
let payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap();
assert_eq!(payload["device_anchor"]["source"], 1);
let decoded = SessionCredential::decode_frame(&frame).unwrap();
assert_eq!(decoded.device_anchor(), Some(&anchor));
}
#[test]
fn credential_rejects_reserved_and_unknown_anchor_sources() {
let credential = SessionCredential::generate(Uuid::new_v4(), "2.6.5").unwrap();
let frame = credential.encode_frame().unwrap();
let mut payload: serde_json::Value = serde_json::from_slice(&frame[2..]).unwrap();
let hardware_id = general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]);
for source in [0, 4] {
payload["device_anchor"] = serde_json::json!({
"hardware_id": hardware_id,
"source": source
});
let bytes = serde_json::to_vec(&payload).unwrap();
let mut invalid_frame = (bytes.len() as u16).to_be_bytes().to_vec();
invalid_frame.extend_from_slice(&bytes);
assert!(SessionCredential::decode_frame(&invalid_frame).is_err());
}
}
}
@@ -22,7 +22,6 @@ pub enum TransportError {
#[serde(tag = "type", rename_all = "camelCase", deny_unknown_fields)]
pub enum HandshakeRejection {
VersionMismatch { client: String, service: String },
HipProtocolMismatch { client: u16, service: u16 },
ServiceRestarted { service_instance_id: Uuid },
ReconnectSuperseded,
Unauthorized,
@@ -7,8 +7,6 @@ use super::{HandshakeRejection, MAX_PRELUDE, MAX_PRODUCT_VERSION, TransportError
#[serde(deny_unknown_fields)]
pub struct ClientPrelude {
pub product_version: String,
#[serde(default)]
pub hip_protocol_version: u16,
pub service_instance_id: Uuid,
pub session_id: Uuid,
}
@@ -73,16 +71,9 @@ mod tests {
r#"{{"product_version":"2.6.4","service_instance_id":"{instance}","session_id":"{session}","extra":true}}"#
);
assert!(ClientPrelude::decode(unknown.as_bytes()).is_err());
let legacy =
format!(r#"{{"product_version":"2.6.4","service_instance_id":"{instance}","session_id":"{session}"}}"#);
assert_eq!(
ClientPrelude::decode(legacy.as_bytes()).unwrap().hip_protocol_version,
0
);
assert!(
ClientPrelude {
product_version: String::new(),
hip_protocol_version: super::super::HIP_PROTOCOL_VERSION,
service_instance_id: instance,
session_id: session,
}
+1 -30
View File
@@ -1,7 +1,6 @@
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::hip::HipApprovalStatus;
use crate::service::{event::WsEvent, request::WsRequest, vpn_env::VpnEnv, vpnc_script::VpncScriptMetadata};
use super::{MAX_PLAINTEXT, MAX_SERVICE_MESSAGE, ServiceErrorCode, TransportError};
@@ -40,20 +39,6 @@ pub enum ServerMessage {
#[serde(tag = "type", content = "data", rename_all = "camelCase", deny_unknown_fields)]
pub enum ServiceResult {
Accepted,
StoredHipReport {
report_id: String,
},
HipUploadProgress {
upload_id: String,
},
HipPreviewChunk {
preview_id: String,
offset: usize,
xml: String,
complete: bool,
},
HipApprovalStatus(HipApprovalStatus),
NoSubmittedHipReport,
VpncScriptMetadata(Option<VpncScriptMetadata>),
Rejected(ServiceRejection),
}
@@ -167,21 +152,7 @@ mod tests {
let gateway = Gateway::new("Gateway".to_string(), "vpn.example.com".to_string());
let info = ConnectInfo::new("portal.example.com".to_string(), gateway.clone(), vec![gateway]);
let certificate_size = MAX_CLIENT_IDENTITY_DATA / 2;
let plan = crate::session::ConnectionPlan::new(
vec![crate::session::AuthenticatedGateway {
gateway: info.gateway().clone(),
binding: Some(crate::session::network::test_binding()),
authentication: crate::session::GatewayAuthentication::new(
"authcookie=token&user=user".into(),
"tunnel".into(),
)
.unwrap(),
}],
vec![],
crate::session::InternalSessionPolicy::default(),
)
.unwrap();
let request = ConnectRequest::new(info, plan)
let request = ConnectRequest::new(info, "cookie".to_string())
.with_certificate_data(Some(vec![b'c'; certificate_size]))
.with_sslkey_data(Some(vec![b'k'; MAX_CLIENT_IDENTITY_DATA - certificate_size]));
let message = ClientMessage::Request {
@@ -13,7 +13,6 @@ pub use noise::{NoiseInitiator, NoiseResponder, NoiseTransport};
pub const MAX_CREDENTIAL_FRAME: usize = 512;
pub const MAX_PRELUDE: usize = 256;
pub const MAX_PRODUCT_VERSION: usize = 64;
pub const HIP_PROTOCOL_VERSION: u16 = 1;
pub const MAX_PLAINTEXT: usize = 60 * 1024;
pub const MAX_WS_MESSAGE: usize = u16::MAX as usize;
pub const MAX_SERVICE_MESSAGE: usize = 256;
+3
View File
@@ -24,6 +24,9 @@ pub struct VpnEnv {
/// The default VPN script path
pub vpnc_script: Option<String>,
/// The default CSD wrapper script path
pub csd_wrapper: Option<String>,
/// The gpauth executable path
/// Used by the client to launch gpauth for authentication
pub auth_executable: String,
+1 -23
View File
@@ -3,10 +3,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Serialize};
use specta::Type;
use crate::{
gateway::Gateway,
session::{GatewayFailureSummary, GatewaySessionSummary, SessionInfo},
};
use crate::{gateway::Gateway, session::SessionInfo};
#[derive(Debug, Deserialize, Serialize, Type, Clone)]
pub struct ConnectInfo {
@@ -21,8 +18,6 @@ pub struct ConnectedInfo {
info: Box<ConnectInfo>,
session_info: Option<SessionInfo>,
connected_at: u32,
members: Vec<GatewaySessionSummary>,
failures: Vec<GatewayFailureSummary>,
}
impl ConnectedInfo {
@@ -31,25 +26,9 @@ impl ConnectedInfo {
info: Box::new(info),
session_info,
connected_at: unix_timestamp(),
members: vec![],
failures: vec![],
}
}
pub fn with_members(mut self, members: Vec<GatewaySessionSummary>, failures: Vec<GatewayFailureSummary>) -> Self {
self.members = members;
self.failures = failures;
self
}
pub fn members(&self) -> &[GatewaySessionSummary] {
&self.members
}
pub fn failures(&self) -> &[GatewayFailureSummary] {
&self.failures
}
pub fn info(&self) -> &ConnectInfo {
&self.info
}
@@ -88,7 +67,6 @@ impl ConnectInfo {
#[serde(rename_all = "camelCase")]
pub enum VpnState {
Disconnected,
Failed(String),
Connecting(Box<ConnectInfo>),
Connected(Box<ConnectedInfo>),
Disconnecting,
-8
View File
@@ -4,14 +4,6 @@ use chrono::{Local, TimeZone};
use serde::{Deserialize, Serialize};
use specta::Type;
mod connection;
mod gateway_sessions;
pub mod network;
pub mod non_tunnel;
pub mod transport;
pub use connection::*;
pub use gateway_sessions::{ClientAddresses, GatewaySession, GatewaySessions};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
pub struct SessionWarning {
pub prior_secs: u32,
-335
View File
@@ -1,335 +0,0 @@
use std::{fmt, time::Duration};
use anyhow::ensure;
use serde::{Deserialize, Serialize};
use specta::Type;
use zeroize::Zeroize;
use crate::gateway::Gateway;
/// Network location and session mode are independent: an internal gateway can
/// still require a tunnel.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum SessionMode {
Tunnel,
NonTunnel,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum MaintenanceState {
Authenticated,
Healthy,
Rejected,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct GatewaySessionSummary {
pub gateway: Gateway,
pub mode: SessionMode,
pub client_ip: Option<String>,
pub client_ipv6: Option<String>,
pub maintenance: MaintenanceState,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum SessionEndReason {
InvalidCookie,
NetworkChanged,
AllMembersFailed,
AuthorizationRevoked,
}
#[derive(Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "GatewayAuthenticationFields")]
pub struct GatewayAuthentication {
cookie: String,
connection_type: String,
}
#[derive(Deserialize)]
struct GatewayAuthenticationFields {
cookie: String,
connection_type: String,
}
impl TryFrom<GatewayAuthenticationFields> for GatewayAuthentication {
type Error = anyhow::Error;
fn try_from(fields: GatewayAuthenticationFields) -> Result<Self, Self::Error> {
Self::new(fields.cookie, fields.connection_type)
}
}
impl GatewayAuthentication {
pub fn new(cookie: String, connection_type: String) -> anyhow::Result<Self> {
let authentication = Self {
cookie,
connection_type,
};
ensure!(
!authentication.cookie.is_empty() && authentication.cookie.len() <= 64 * 1024,
"Gateway authentication cookie is missing or too large"
);
let params = url::form_urlencoded::parse(authentication.cookie.as_bytes()).collect::<Vec<_>>();
for key in ["authcookie", "user"] {
let mut values = params.iter().filter(|(name, _)| name == key).map(|(_, value)| value);
ensure!(
values.next().is_some_and(|value| !value.is_empty()) && values.next().is_none(),
"Gateway authentication requires one nonempty {key}"
);
}
ensure!(
!authentication.connection_type.trim().is_empty()
&& authentication.connection_type != "(null)"
&& authentication.connection_type != "-1",
"Gateway connection type is missing"
);
Ok(authentication)
}
pub fn cookie(&self) -> &str {
&self.cookie
}
pub fn connection_type(&self) -> &str {
&self.connection_type
}
pub fn mode(&self) -> SessionMode {
if self.connection_type == "tunnel" {
SessionMode::Tunnel
} else {
SessionMode::NonTunnel
}
}
}
impl fmt::Debug for GatewayAuthentication {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("GatewayAuthentication")
.field("cookie", &"<redacted>")
.field("mode", &self.mode())
.finish()
}
}
impl Drop for GatewayAuthentication {
fn drop(&mut self) {
self.cookie.zeroize();
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", try_from = "InternalSessionPolicyFields")]
pub struct InternalSessionPolicy {
hip_interval_secs: u32,
collect_hip_data: bool,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct InternalSessionPolicyFields {
hip_interval_secs: u32,
collect_hip_data: bool,
}
impl TryFrom<InternalSessionPolicyFields> for InternalSessionPolicy {
type Error = anyhow::Error;
fn try_from(fields: InternalSessionPolicyFields) -> Result<Self, Self::Error> {
Self::new(fields.hip_interval_secs, fields.collect_hip_data)
}
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
pub struct AuthenticatedGateway {
pub gateway: Gateway,
pub authentication: GatewayAuthentication,
pub binding: Option<super::network::GatewayBinding>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum GatewayFailure {
AuthenticationRejected,
Unreachable,
TunnelFailed,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
pub struct GatewayFailureSummary {
pub gateway: Gateway,
pub failure: GatewayFailure,
}
/// Credentials remain in the interactive authentication owner; only issued
/// gateway cookies cross the runtime/service boundary.
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "ConnectionPlanFields")]
pub struct ConnectionPlan {
members: Vec<AuthenticatedGateway>,
failures: Vec<GatewayFailureSummary>,
policy: InternalSessionPolicy,
internal_detection: Option<super::network::InternalHostDetection>,
}
#[derive(Deserialize)]
struct ConnectionPlanFields {
members: Vec<AuthenticatedGateway>,
failures: Vec<GatewayFailureSummary>,
policy: InternalSessionPolicy,
internal_detection: Option<super::network::InternalHostDetection>,
}
impl TryFrom<ConnectionPlanFields> for ConnectionPlan {
type Error = anyhow::Error;
fn try_from(fields: ConnectionPlanFields) -> Result<Self, Self::Error> {
Ok(Self::new(fields.members, fields.failures, fields.policy)?.with_internal_detection(fields.internal_detection))
}
}
impl ConnectionPlan {
pub fn new(
members: Vec<AuthenticatedGateway>,
failures: Vec<GatewayFailureSummary>,
policy: InternalSessionPolicy,
) -> anyhow::Result<Self> {
ensure!(!members.is_empty(), "Connection plan has no authenticated gateways");
ensure!(
members.len() <= 64 && failures.len() <= 64,
"Connection plan exceeds its gateway limit"
);
let mode = members[0].authentication.mode();
ensure!(
members.iter().all(|member| member.authentication.mode() == mode),
"Mixed tunnel and non-tunnel sessions are unsupported"
);
ensure!(
mode != SessionMode::NonTunnel
|| members
.iter()
.all(|member| member.gateway.kind() == crate::gateway::GatewayKind::Internal),
"Non-tunnel sessions require freshly discovered internal gateways"
);
ensure!(
members.len() == 1
|| members
.iter()
.all(|member| member.gateway.kind() == crate::gateway::GatewayKind::Internal),
"Multiple authenticated gateways require an internal connection"
);
let mut hosts = std::collections::HashSet::new();
for member in &members {
if mode == SessionMode::NonTunnel {
let binding = member
.binding
.as_ref()
.ok_or_else(|| anyhow::anyhow!("Non-tunnel session has no physical binding"))?;
binding.validate_server(member.gateway.server())?;
}
let host = crate::utils::normalize_server(member.gateway.server())?;
ensure!(hosts.insert(host), "Connection plan has duplicate gateways");
}
Ok(Self {
members,
failures,
policy,
internal_detection: None,
})
}
pub fn members(&self) -> &[AuthenticatedGateway] {
&self.members
}
pub fn failures(&self) -> &[GatewayFailureSummary] {
&self.failures
}
pub fn policy(&self) -> InternalSessionPolicy {
self.policy
}
pub fn mode(&self) -> SessionMode {
self.members[0].authentication.mode()
}
pub fn with_internal_detection(mut self, detection: Option<super::network::InternalHostDetection>) -> Self {
self.internal_detection = detection;
self
}
pub fn internal_detection(&self) -> Option<&super::network::InternalHostDetection> {
self.internal_detection.as_ref()
}
}
impl Default for InternalSessionPolicy {
fn default() -> Self {
Self {
hip_interval_secs: 3600,
collect_hip_data: true,
}
}
}
impl InternalSessionPolicy {
pub fn new(hip_interval_secs: u32, collect_hip_data: bool) -> anyhow::Result<Self> {
ensure!(hip_interval_secs > 0, "HIP report interval must be positive");
ensure!(
hip_interval_secs.checked_mul(1000).is_some(),
"HIP report interval exceeds the supported range"
);
Ok(Self {
hip_interval_secs,
collect_hip_data,
})
}
pub fn hip_interval(&self) -> Duration {
Duration::from_secs(u64::from(self.hip_interval_secs))
}
pub fn collect_hip_data(&self) -> bool {
self.collect_hip_data
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn deserialization_enforces_authentication_invariants() {
for (cookie, mode) in [
("", "tunnel"),
("not-a-cookie", "tunnel"),
("user=alice", "tunnel"),
("authcookie=token", "tunnel"),
("authcookie=token&user=alice&user=bob", "tunnel"),
("authcookie=token&user=alice", ""),
] {
let serialized = serde_json::json!({"cookie":cookie, "connection_type":mode});
assert!(serde_json::from_value::<GatewayAuthentication>(serialized).is_err());
}
let auth = GatewayAuthentication::new("authcookie=token&user=alice".into(), "non-tunnel".into()).unwrap();
let decoded: GatewayAuthentication = serde_json::from_str(&serde_json::to_string(&auth).unwrap()).unwrap();
assert_eq!(decoded.mode(), SessionMode::NonTunnel);
}
#[test]
fn deserialization_enforces_schedule_invariants() {
for interval in [0, u32::MAX] {
let serialized = serde_json::json!({"hipIntervalSecs":interval,"collectHipData":false});
assert!(serde_json::from_value::<InternalSessionPolicy>(serialized).is_err());
}
let serialized = serde_json::to_string(&InternalSessionPolicy::default()).unwrap();
let decoded: InternalSessionPolicy = serde_json::from_str(&serialized).unwrap();
assert_eq!(decoded.hip_interval(), Duration::from_secs(3600));
}
}
@@ -1,103 +0,0 @@
use std::{
net::{Ipv4Addr, Ipv6Addr},
sync::Arc,
time::Duration,
};
use crate::gateway::Gateway;
use super::transport::GatewayTransport;
const LOGOUT_TIMEOUT: Duration = Duration::from_secs(5);
#[derive(Clone, Copy, Debug, Default, serde::Serialize, serde::Deserialize, specta::Type)]
pub struct ClientAddresses {
pub ipv4: Option<Ipv4Addr>,
pub ipv6: Option<Ipv6Addr>,
}
/// One issued gateway authentication and its original request context. Session
/// mode governs execution, while every mode has the same cleanup owner.
pub struct GatewaySession {
pub gateway: Gateway,
pub transport: GatewayTransport,
pub addresses: ClientAddresses,
}
/// Owns issued gateway sessions independently of tunnel or HIP setup. Workers
/// borrow members; their owner joins them before consuming this ledger in logout.
/// This owner is deliberately not Clone: transfer or drain it exactly once.
#[derive(Default)]
pub struct GatewaySessions {
members: Vec<Arc<GatewaySession>>,
}
impl GatewaySessions {
pub fn new(members: Vec<GatewaySession>) -> Self {
Self {
members: members.into_iter().map(Arc::new).collect(),
}
}
pub fn register(&mut self, session: GatewaySession) {
self.members.push(Arc::new(session));
}
pub(crate) fn update(&mut self, session: GatewaySession) {
if let Some(member) = self
.members
.iter_mut()
.find(|member| member.gateway.server() == session.gateway.server())
{
*member = Arc::new(session);
}
}
pub fn is_empty(&self) -> bool {
self.members.is_empty()
}
/// Consume the local cleanup copies only after another owner has proved it
/// acquired responsibility for these issued sessions.
pub fn relinquish(self) {}
pub fn members(&self) -> &[Arc<GatewaySession>] {
&self.members
}
/// Transfer a selected tunnel login to OpenConnect immediately before its
/// native worker starts. OpenConnect owns the live reconnect cookie and logout.
pub fn relinquish_gateway(&mut self, server: &str) {
if let Some(index) = self.members.iter().position(|member| member.gateway.server() == server) {
self.members.remove(index);
}
}
/// Call only after this member's worker has joined. Removing ownership before
/// awaiting logout prevents routine final cleanup from repeating the request.
pub async fn logout_gateway(&mut self, server: &str) {
if let Some(index) = self.members.iter().position(|member| member.gateway.server() == server) {
logout(self.members.remove(index)).await;
}
}
pub async fn logout(self) {
let mut workers = tokio::task::JoinSet::new();
for session in self.members {
workers.spawn(logout(session));
}
while let Some(result) = workers.join_next().await {
if let Err(error) = result {
log::warn!("Gateway cleanup worker failed: {error}");
}
}
}
}
async fn logout(session: Arc<GatewaySession>) {
match tokio::time::timeout(LOGOUT_TIMEOUT, session.transport.logout()).await {
Ok(Ok(())) => {}
Ok(Err(error)) => log::warn!("Gateway logout failed: {error}"),
Err(_) => log::warn!("Gateway logout timed out"),
}
}
-223
View File
@@ -1,223 +0,0 @@
use std::net::{IpAddr, SocketAddr};
use anyhow::ensure;
use serde::{Deserialize, Serialize};
use specta::Type;
use super::super::ClientAddresses;
/// Physical network context bound to the authenticated non-tunnel endpoint. Wire input is validated;
/// runtime transports use this context without performing another DNS lookup.
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "BindingFields", rename_all = "camelCase")]
pub struct GatewayBinding {
endpoint: SocketAddr,
source: SocketAddr,
interface: String,
interface_index: u32,
addresses: ClientAddresses,
network_fingerprint: Option<String>,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
struct BindingFields {
endpoint: SocketAddr,
source: SocketAddr,
interface: String,
interface_index: u32,
addresses: ClientAddresses,
network_fingerprint: Option<String>,
}
impl TryFrom<BindingFields> for GatewayBinding {
type Error = anyhow::Error;
fn try_from(fields: BindingFields) -> Result<Self, Self::Error> {
Self::new(
fields.endpoint,
fields.source,
fields.interface,
fields.interface_index,
fields.addresses,
fields.network_fingerprint,
)
}
}
impl GatewayBinding {
pub fn new(
endpoint: SocketAddr,
source: SocketAddr,
interface: String,
interface_index: u32,
addresses: ClientAddresses,
network_fingerprint: impl Into<Option<String>>,
) -> anyhow::Result<Self> {
let network_fingerprint = network_fingerprint.into();
ensure!(
network_fingerprint
.as_ref()
.is_none_or(|value| value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_hexdigit())),
"Physical network fingerprint is invalid"
);
ensure!(
endpoint.port() != 0 && !endpoint.ip().is_unspecified() && !endpoint.ip().is_multicast(),
"Gateway endpoint is invalid"
);
ensure!(
source.port() == 0 && !source.ip().is_unspecified() && !source.ip().is_multicast(),
"Gateway source is invalid"
);
ensure!(
endpoint.is_ipv4() == source.is_ipv4(),
"Gateway address families differ"
);
ensure!(
!interface.is_empty() && interface.len() < 64 && !interface.contains('\0') && interface_index != 0,
"Gateway interface is invalid"
);
for address in [endpoint, source] {
if let SocketAddr::V6(address) = address {
ensure!(address.flowinfo() == 0, "Gateway IPv6 flow information is invalid");
ensure!(
address.scope_id() == 0 || address.scope_id() == interface_index,
"Gateway IPv6 scope differs from its interface"
);
ensure!(
!address.ip().is_unicast_link_local() || address.scope_id() == interface_index,
"Gateway IPv6 scope is missing"
);
}
}
match source.ip() {
IpAddr::V4(ip) => ensure!(
addresses.ipv4 == Some(ip),
"Gateway IPv4 source differs from its identity"
),
IpAddr::V6(ip) => ensure!(
addresses.ipv6 == Some(ip),
"Gateway IPv6 source differs from its identity"
),
}
Ok(Self {
endpoint,
source,
interface,
interface_index,
addresses,
network_fingerprint,
})
}
pub fn endpoint(&self) -> SocketAddr {
self.endpoint
}
pub fn source(&self) -> SocketAddr {
self.source
}
pub fn interface(&self) -> &str {
&self.interface
}
pub fn interface_index(&self) -> u32 {
self.interface_index
}
pub fn addresses(&self) -> ClientAddresses {
self.addresses
}
pub fn network_fingerprint(&self) -> Option<&str> {
self.network_fingerprint.as_deref()
}
pub fn validate_server(&self, server: &str) -> anyhow::Result<()> {
let origin = super::super::transport::gateway_origin(server)?;
ensure!(
origin.port_or_known_default() == Some(self.endpoint.port()),
"Gateway endpoint port differs"
);
let literal = match origin.host() {
Some(url::Host::Ipv4(ip)) => Some(IpAddr::V4(ip)),
Some(url::Host::Ipv6(ip)) => Some(IpAddr::V6(ip)),
_ => None,
};
if let Some(ip) = literal {
ensure!(self.endpoint.ip() == ip, "Literal gateway endpoint differs");
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
fn ipv4_binding() -> GatewayBinding {
GatewayBinding::new(
"192.0.2.10:443".parse().unwrap(),
"192.0.2.5:0".parse().unwrap(),
"fixture".into(),
7,
ClientAddresses {
ipv4: Some("192.0.2.5".parse().unwrap()),
ipv6: None,
},
"a".repeat(64),
)
.unwrap()
}
#[test]
fn wire_input_rejects_inconsistent_network_identity() {
let original = serde_json::to_value(ipv4_binding()).unwrap();
for (field, value) in [
("source", serde_json::json!("192.0.2.6:0")),
("source", serde_json::json!("192.0.2.5:1234")),
("endpoint", serde_json::json!("[2001:db8::10]:443")),
("interfaceIndex", serde_json::json!(0)),
("networkFingerprint", serde_json::json!("not-a-fingerprint")),
] {
let mut invalid = original.clone();
invalid[field] = value;
assert!(
serde_json::from_value::<GatewayBinding>(invalid).is_err(),
"accepted {field}"
);
}
assert!(serde_json::from_value::<GatewayBinding>(original).is_ok());
}
#[test]
fn link_local_scope_survives_wire_round_trip_and_must_match_interface() {
let addresses = ClientAddresses {
ipv4: None,
ipv6: Some("fe80::5".parse().unwrap()),
};
let binding = GatewayBinding::new(
"[fe80::10%7]:443".parse().unwrap(),
"[fe80::5%7]:0".parse().unwrap(),
"fixture".into(),
7,
addresses,
"a".repeat(64),
)
.unwrap();
let value = serde_json::to_value(&binding).unwrap();
let restored: GatewayBinding = serde_json::from_value(value.clone()).unwrap();
assert_eq!(restored.source(), binding.source());
assert_eq!(restored.endpoint(), binding.endpoint());
for source in ["[fe80::5]:0", "[fe80::5%8]:0"] {
let mut invalid = value.clone();
invalid["source"] = serde_json::json!(source);
assert!(serde_json::from_value::<GatewayBinding>(invalid).is_err());
}
}
#[test]
fn server_origin_must_match_endpoint_port_and_literal_address() {
let binding = ipv4_binding();
assert!(binding.validate_server("gateway.example.com").is_ok());
assert!(binding.validate_server("192.0.2.10").is_ok());
assert!(binding.validate_server("192.0.2.11").is_err());
assert!(binding.validate_server("gateway.example.com:444").is_err());
}
}
-16
View File
@@ -1,16 +0,0 @@
pub(super) use super::bsd_routes::routes;
use super::*;
pub(super) fn scope_resolver_socket(
_socket: &tokio::net::UdpSocket,
_interface: &Interface,
_endpoint: SocketAddr,
) -> anyhow::Result<()> {
// resolv.conf has no per-interface resolver contexts. IPv6 zones are carried
// in the destination address instead.
anyhow::bail!("Interface-scoped resolver contexts are unsupported on BSD")
}
pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
resolv_conf(control)
}
@@ -1,60 +0,0 @@
use super::*;
#[cfg(any(target_os = "freebsd", target_os = "openbsd", target_os = "macos"))]
pub(super) fn routes(control: &dyn CollectionControl) -> anyhow::Result<Vec<RouteContext>> {
let mut routes = Vec::new();
for family in ["inet", "inet6"] {
routes.extend(parse_routes(&command("netstat", &["-rn", "-f", family], control)?)?);
}
Ok(routes)
}
fn parse_routes(contents: &str) -> anyhow::Result<Vec<RouteContext>> {
let mut interface_column = None;
let mut routes = Vec::new();
for line in contents.lines() {
let fields = line.split_whitespace().collect::<Vec<_>>();
if fields.first() == Some(&"Destination") {
interface_column = Some(
fields
.iter()
.position(|field| matches!(*field, "Netif" | "Iface"))
.context("Route table has no interface column")?,
);
continue;
}
let Some(column) = interface_column else {
continue;
};
if fields.len() <= column {
continue;
}
// L/W entries are neighbor-cache or cloned host routes. Their presence,
// gateway MAC and expiry depend on traffic and must not cause rediscovery.
if fields[2].contains('L') || fields[2].contains('W') {
continue;
}
routes.push(RouteContext {
destination: fields[0].into(),
gateway: fields[1].into(),
interface: fields[column].into(),
table: String::new(),
metric: String::new(),
});
}
ensure!(interface_column.is_some(), "Route table header is missing");
Ok(routes)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ignores_route_use_expiry_and_platform_column_positions() {
let darwin = parse_routes("Routing tables\nInternet:\nDestination Gateway Flags Netif Expire\ndefault 192.0.2.1 UGScg en0\n192.0.2.5 aa:bb:cc:dd:ee:ff UHLWI en0 123").unwrap();
let bsd = parse_routes("Destination Gateway Flags Refs Use Mtu Netif Expire\ndefault 192.0.2.1 UGS 4 22 1500 en0\n192.0.2.5 aa:bb:cc:dd:ee:ff UHL 0 33 1500 en0 99").unwrap();
assert_eq!(darwin, bsd);
assert_eq!(darwin.len(), 1);
assert!(parse_routes("unrecognized table").is_err());
}
}
@@ -1,94 +0,0 @@
use std::net::IpAddr;
use anyhow::ensure;
use serde::{Deserialize, Serialize};
use specta::Type;
use tokio_util::sync::CancellationToken;
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(try_from = "DetectionFields")]
pub struct InternalHostDetection {
targets: Vec<DetectionTarget>,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
struct DetectionTarget {
address: IpAddr,
hostname: String,
}
#[derive(Deserialize)]
struct DetectionFields {
targets: Vec<DetectionTarget>,
}
impl TryFrom<DetectionFields> for InternalHostDetection {
type Error = anyhow::Error;
fn try_from(fields: DetectionFields) -> anyhow::Result<Self> {
Self::new(
fields
.targets
.into_iter()
.map(|target| (target.address, target.hostname))
.collect(),
)
}
}
impl InternalHostDetection {
pub fn new(targets: Vec<(IpAddr, String)>) -> anyhow::Result<Self> {
ensure!(
!targets.is_empty() && targets.len() <= 2,
"Invalid internal detection target count"
);
let targets = targets
.into_iter()
.map(|(address, hostname)| {
validate_target(address, &hostname)?;
Ok(DetectionTarget { address, hostname })
})
.collect::<anyhow::Result<Vec<_>>>()?;
Ok(Self { targets })
}
pub async fn detect(&self, cancellation: &CancellationToken) -> anyhow::Result<bool> {
for target in &self.targets {
if super::native::detect(target.address, &target.hostname, cancellation).await? {
return Ok(true);
}
}
Ok(false)
}
}
pub(super) fn validate_target(address: IpAddr, hostname: &str) -> anyhow::Result<()> {
ensure!(
!address.is_unspecified() && !address.is_loopback() && !address.is_multicast(),
"Invalid internal detection address"
);
ensure!(
!hostname.is_empty()
&& hostname.len() <= 253
&& hostname.is_ascii()
&& hostname
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b'_')),
"Invalid internal detection hostname"
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detection_inputs_are_retained_and_validated_on_deserialization() {
let detection = InternalHostDetection::new(vec![("192.0.2.10".parse().unwrap(), "host.example".into())]).unwrap();
let value = serde_json::to_value(&detection).unwrap();
assert!(serde_json::from_value::<InternalHostDetection>(value).is_ok());
assert!(InternalHostDetection::new(vec![]).is_err());
assert!(InternalHostDetection::new(vec![("127.0.0.1".parse().unwrap(), "host.example".into())]).is_err());
}
}
-131
View File
@@ -1,131 +0,0 @@
use super::*;
#[cfg(target_os = "linux")]
pub(super) fn scope_resolver_socket(
socket: &tokio::net::UdpSocket,
interface: &Interface,
_endpoint: SocketAddr,
) -> anyhow::Result<()> {
socket2::SockRef::from(socket).bind_device(Some(interface.name.as_bytes()))?;
Ok(())
}
#[cfg(target_os = "linux")]
pub(super) fn routes(control: &dyn CollectionControl) -> anyhow::Result<Vec<RouteContext>> {
let mut routes = Vec::new();
for family in ["-4", "-6"] {
routes.extend(parse_routes(&command(
"ip",
&[family, "-j", "route", "show", "table", "all"],
control,
)?)?);
}
Ok(routes)
}
fn parse_routes(contents: &str) -> anyhow::Result<Vec<RouteContext>> {
let value: Vec<serde_json::Value> = serde_json::from_str(contents)?;
let mut routes = Vec::new();
for route in value {
// Kernel cache and neighbor lifetimes are traffic, not network changes.
if route.get("cache").is_some() {
continue;
}
let Some(interface) = route["dev"].as_str() else {
continue;
};
let field = |name| {
route
.get(name)
.map(|value| value.as_str().map(str::to_owned).unwrap_or_else(|| value.to_string()))
.unwrap_or_default()
};
routes.push(RouteContext {
destination: field("dst"),
gateway: field("gateway"),
interface: interface.into(),
table: field("table"),
metric: field("metric"),
});
}
Ok(routes)
}
#[cfg(target_os = "linux")]
pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
let path = std::fs::canonicalize("/etc/resolv.conf")?;
if path.starts_with("/run/systemd/resolve") {
let dns = command("resolvectl", &["dns"], control)?;
let domains = command("resolvectl", &["domain"], control)?;
return parse_resolved(&dns, &domains);
}
resolv_conf(control)
}
fn parse_resolved(dns: &str, domains: &str) -> anyhow::Result<Vec<ResolverContext>> {
let mut resolvers = std::collections::BTreeMap::<Option<String>, ResolverContext>::new();
for (contents, is_dns) in [(dns, true), (domains, false)] {
for line in contents.lines().filter(|line| !line.trim().is_empty()) {
let (label, values) = line.split_once(':').context("Invalid systemd resolver output")?;
let interface = if label == "Global" {
None
} else {
let (_, name) = label.split_once('(').context("Invalid systemd resolver interface")?;
Some(
name
.strip_suffix(')')
.context("Invalid systemd resolver interface")?
.to_owned(),
)
};
let resolver = resolvers.entry(interface.clone()).or_insert_with(|| ResolverContext {
interface,
servers: Vec::new(),
domains: Vec::new(),
});
if is_dns {
for server in values.split_whitespace() {
server
.split('%')
.next()
.unwrap_or_default()
.parse::<IpAddr>()
.context("Invalid systemd resolver address")?;
resolver.servers.push(server.to_owned());
}
} else {
resolver
.domains
.extend(values.split_whitespace().map(|domain| domain.to_ascii_lowercase()));
}
}
}
Ok(resolvers.into_values().collect())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn route_identity_retains_ipv6_and_ignores_cache() {
let routes = parse_routes(r#"[{"dst":"default","gateway":"2001:db8::1","dev":"eth0","metric":600,"table":"main"},{"dst":"2001:db8::5","dev":"eth0","cache":[]}]"#).unwrap();
assert_eq!(routes.len(), 1);
assert_eq!(routes[0].gateway, "2001:db8::1");
assert_eq!(routes[0].metric, "600");
}
#[test]
fn resolved_preserves_interface_domains_and_empty_global_context() {
let resolvers = parse_resolved(
"Global:\nLink 2 (eth0): 192.0.2.53\n\nLink 3 (tun0): 198.51.100.53\n",
"Global:\nLink 2 (eth0): CORP.EXAMPLE\nLink 3 (tun0): ~.\n",
)
.unwrap();
assert_eq!(resolvers.len(), 3);
assert!(
resolvers
.iter()
.any(|resolver| resolver.interface.as_deref() == Some("eth0")
&& resolver.domains.iter().any(|domain| domain == "corp.example"))
);
}
}
-89
View File
@@ -1,89 +0,0 @@
pub(super) use super::bsd_routes::routes;
use super::*;
pub(super) fn scope_resolver_socket(
socket: &tokio::net::UdpSocket,
interface: &Interface,
endpoint: SocketAddr,
) -> anyhow::Result<()> {
let index = std::num::NonZeroU32::new(interface.index).context("Resolver interface index is missing")?;
let socket = socket2::SockRef::from(socket);
if endpoint.is_ipv4() {
socket.bind_device_by_index_v4(Some(index))?;
} else {
socket.bind_device_by_index_v6(Some(index))?;
}
Ok(())
}
pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
parse_resolvers(&command("scutil", &["--dns"], control)?)
}
fn parse_resolvers(contents: &str) -> anyhow::Result<Vec<ResolverContext>> {
let mut resolvers = Vec::new();
let mut current: Option<ResolverContext> = None;
for line in contents.lines().map(str::trim) {
if line.starts_with("resolver #") {
if let Some(resolver) = current.take() {
resolvers.push(resolver);
}
current = Some(ResolverContext {
interface: None,
servers: Vec::new(),
domains: Vec::new(),
});
continue;
}
let Some(resolver) = &mut current else {
continue;
};
let Some((field, value)) = line.split_once(':') else {
continue;
};
let field = field.trim();
let value = value.trim();
if field.starts_with("nameserver[") {
value
.split('%')
.next()
.unwrap_or_default()
.parse::<IpAddr>()
.context("Invalid macOS resolver address")?;
resolver.servers.push(value.to_owned());
} else if field == "domain" || field.starts_with("search domain[") {
resolver.domains.push(value.to_ascii_lowercase());
} else if field == "if_index" {
if let Some((_, name)) = value.split_once('(') {
resolver.interface = Some(
name
.strip_suffix(')')
.context("Invalid macOS resolver interface")?
.to_owned(),
);
}
}
}
if let Some(resolver) = current {
resolvers.push(resolver);
}
Ok(resolvers)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolver_identity_is_scoped_and_ignores_reachability_counters() {
let a = parse_resolvers(
"resolver #1\n nameserver[0] : 192.0.2.53\n if_index : 4 (en0)\n search domain[0] : CORP.EXAMPLE\n reach : 2",
)
.unwrap();
let b = parse_resolvers(
"resolver #9\n search domain[0] : corp.example\n if_index : 4 (en0)\n nameserver[0] : 192.0.2.53\n reach : 3",
)
.unwrap();
assert_eq!(a, b);
assert_eq!(a[0].interface.as_deref(), Some("en0"));
}
}
-680
View File
@@ -1,680 +0,0 @@
use std::{
collections::BTreeSet,
io,
net::{IpAddr, SocketAddr},
time::Duration,
};
use anyhow::{Context, ensure};
use netdev::Interface;
use tokio_util::sync::CancellationToken;
use super::ClientAddresses;
use crate::process::collection::{CollectionBudget, CollectionControl, CollectorCommands};
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
mod bsd;
#[cfg(any(target_os = "freebsd", target_os = "openbsd", target_os = "macos", test))]
mod bsd_routes;
#[cfg(any(target_os = "linux", test))]
mod linux;
#[cfg(target_os = "macos")]
mod macos;
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
use bsd as platform;
#[cfg(target_os = "linux")]
use linux as platform;
#[cfg(target_os = "macos")]
use macos as platform;
mod binding;
mod detection;
pub mod native;
pub use binding::GatewayBinding;
pub use detection::InternalHostDetection;
const INSPECTION_TIMEOUT: Duration = Duration::from_secs(5);
const POLL_INTERVAL: Duration = Duration::from_secs(5);
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
struct InterfaceIdentity {
index: u32,
name: String,
mac: Option<String>,
flags: u32,
addresses: BTreeSet<(String, u32)>,
}
impl From<&Interface> for InterfaceIdentity {
fn from(interface: &Interface) -> Self {
let mut addresses = interface
.ipv4
.iter()
.map(|ip| (ip.to_string(), 0))
.collect::<BTreeSet<_>>();
addresses.extend(interface.ipv6.iter().enumerate().map(|(index, ip)| {
(
ip.to_string(),
interface.ipv6_scope_ids.get(index).copied().unwrap_or_default(),
)
}));
Self {
index: interface.index,
name: interface.name.clone(),
mac: interface.mac_addr.map(|mac| mac.to_string()),
flags: interface.flags,
addresses,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
struct RouteContext {
destination: String,
gateway: String,
interface: String,
table: String,
metric: String,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize)]
struct ResolverContext {
interface: Option<String>,
servers: Vec<String>,
domains: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
struct NetworkSnapshot {
interfaces: BTreeSet<InterfaceIdentity>,
routes: BTreeSet<RouteContext>,
resolvers: Vec<ResolverContext>,
}
/// Captured before this attempt installs a tunnel. Interface counters and
/// timestamps do not participate in identity; routes and resolver context do.
#[derive(Clone)]
pub struct PhysicalNetwork {
snapshot: NetworkSnapshot,
interfaces: Vec<Interface>,
}
impl PhysicalNetwork {
pub async fn bind_authenticated_endpoint(
&self,
server: &str,
endpoint: SocketAddr,
disable_ipv6: bool,
cancellation: &CancellationToken,
) -> anyhow::Result<GatewayBinding> {
self.ensure_current(cancellation).await?;
let binding = resolve_binding(
&self.interfaces,
Some(self.fingerprint()?),
server,
disable_ipv6,
cancellation,
endpoint,
)
.await?;
self.ensure_current(cancellation).await?;
Ok(binding)
}
pub async fn validate_internal_binding(
&self,
binding: &GatewayBinding,
detection: Option<&InternalHostDetection>,
cancellation: &CancellationToken,
) -> anyhow::Result<()> {
self.validate_binding(binding, cancellation).await?;
physical_interface_for_source(&self.interfaces, binding.source(), binding.endpoint())?;
self.validate_internal(detection, cancellation).await
}
pub async fn validate_internal(
&self,
detection: Option<&InternalHostDetection>,
cancellation: &CancellationToken,
) -> anyhow::Result<()> {
self.ensure_current(cancellation).await?;
let mut resolver_count = 0;
for resolver in &self.snapshot.resolvers {
if resolver.servers.is_empty() {
continue;
}
for server in &resolver.servers {
let endpoint = resolver_endpoint(server, resolver.interface.as_deref(), &self.interfaces)?;
ensure!(
!endpoint.ip().is_loopback() && !endpoint.ip().is_unspecified(),
"Unattributed local DNS stub is unsupported"
);
let socket = tokio::net::UdpSocket::bind(if endpoint.is_ipv4() { "0.0.0.0:0" } else { "[::]:0" }).await?;
if let Some(name) = &resolver.interface {
let interface = self
.interfaces
.iter()
.find(|interface| interface.name == *name)
.context("Configured resolver interface is missing")?;
platform::scope_resolver_socket(&socket, interface, endpoint)?;
}
socket.connect(endpoint).await?;
let interface = physical_interface_for_source(&self.interfaces, socket.local_addr()?, endpoint)?;
ensure!(
resolver.interface.as_deref().is_none_or(|name| name == interface.name),
"Resolver route differs from its configured interface"
);
resolver_count += 1;
}
}
ensure!(resolver_count > 0, "Physical resolver context is unavailable");
if let Some(detection) = detection {
ensure!(
detection.detect(cancellation).await?,
"Internal host detection no longer matches"
);
}
self.ensure_current(cancellation).await
}
pub async fn capture_controlled(cancellation: &CancellationToken) -> anyhow::Result<Self> {
let cancellation = cancellation.clone();
tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(INSPECTION_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(io::ErrorKind::Interrupted, "Network capture cancelled"));
}
budget.check()
};
Self::capture(&check)
})
.await?
}
pub async fn validate_binding(
&self,
binding: &GatewayBinding,
cancellation: &CancellationToken,
) -> anyhow::Result<()> {
self.ensure_current(cancellation).await?;
ensure!(
binding.network_fingerprint() == Some(self.fingerprint()?.as_str()),
"Physical network changed since authentication"
);
let interface = self
.interfaces
.iter()
.find(|interface| interface.index == binding.interface_index() && interface.name == binding.interface())
.context("Authenticated gateway interface is no longer present")?;
let addresses = binding.addresses();
ensure!(
addresses
.ipv4
.is_none_or(|ip| interface.ipv4.iter().any(|address| address.addr() == ip)),
"Authenticated IPv4 address changed"
);
ensure!(
addresses
.ipv6
.is_none_or(|ip| interface.ipv6.iter().any(|address| address.addr() == ip)),
"Authenticated IPv6 address changed"
);
Ok(())
}
fn fingerprint(&self) -> anyhow::Result<String> {
Ok(sha256::digest(serde_json::to_vec(&self.snapshot)?))
}
pub fn capture(control: &dyn CollectionControl) -> anyhow::Result<Self> {
control.check()?;
let mut interfaces = netdev::get_interfaces();
for interface in &mut interfaces {
interface.ipv4.sort();
// The address and its zone must move together when native enumeration
// order changes between captures.
let mut ipv6 = interface
.ipv6
.iter()
.copied()
.enumerate()
.map(|(index, address)| {
(
address,
interface.ipv6_scope_ids.get(index).copied().unwrap_or_default(),
)
})
.collect::<Vec<_>>();
ipv6.sort();
interface.ipv6 = ipv6.iter().map(|(address, _)| *address).collect();
interface.ipv6_scope_ids = ipv6.into_iter().map(|(_, scope)| scope).collect();
}
let snapshot = snapshot(&interfaces, control)?;
control.check()?;
Ok(Self { snapshot, interfaces })
}
/// Validate endpoint selection against the captured network. The inspection
/// is joined even when cancellation occurs, so native collectors cannot outlive
/// the connection attempt.
pub async fn ensure_current(&self, cancellation: &CancellationToken) -> anyhow::Result<()> {
let current = inspect(cancellation.clone()).await?;
ensure!(
current == self.snapshot,
"Physical network changed during gateway setup"
);
Ok(())
}
/// The owner must cancel and await this monitor, including its blocking
/// inspection. Dropping a selected future would detach the native collector.
pub async fn wait_for_change(
&self,
detection: Option<InternalHostDetection>,
cancellation: CancellationToken,
) -> anyhow::Result<bool> {
loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => return Ok(false),
_ = tokio::time::sleep(POLL_INTERVAL) => {},
}
let current = self.validate_internal(detection.as_ref(), &cancellation).await;
if cancellation.is_cancelled() {
return Ok(false);
}
if current.is_err() {
return Ok(true);
}
}
}
}
async fn resolve_binding(
interfaces: &[Interface],
fingerprint: Option<String>,
server: &str,
disable_ipv6: bool,
cancellation: &CancellationToken,
authenticated_endpoint: SocketAddr,
) -> anyhow::Result<GatewayBinding> {
let origin = super::transport::gateway_origin(server)?;
let host = origin.host_str().context("Gateway host is missing")?;
let port = origin.port_or_known_default().context("Gateway port is missing")?;
let literal = literal_gateway_address(&origin)?;
let endpoints = if let Some(ip) = literal {
vec![SocketAddr::new(ip, port)]
} else {
native::resolve(host, port, disable_ipv6, cancellation).await?
};
ensure!(
endpoints.contains(&authenticated_endpoint),
"Authenticated peer differs from the gateway's current DNS addresses; check for a proxy or changed DNS answer"
);
let endpoint = authenticated_endpoint;
ensure!(
!(disable_ipv6 && endpoint.is_ipv6()),
"Authenticated gateway uses disabled IPv6"
);
let bind = if endpoint.is_ipv4() { "0.0.0.0:0" } else { "[::]:0" };
let socket = tokio::net::UdpSocket::bind(bind).await?;
socket.connect(endpoint).await?;
let mut source_address = socket.local_addr()?;
source_address.set_port(0);
let source = source_address.ip();
let interface = physical_interface_for_source(interfaces, source_address, endpoint)?;
let ipv4 = match source {
IpAddr::V4(ip) => Some(ip),
_ => interface
.ipv4
.iter()
.map(|ip| ip.addr())
.find(|ip| !ip.is_loopback() && !ip.is_unspecified()),
};
let ipv6 = if disable_ipv6 {
None
} else {
match source {
IpAddr::V6(ip) => Some(ip),
_ => interface
.ipv6
.iter()
.map(|ip| ip.addr())
.find(|ip| !ip.is_loopback() && !ip.is_unspecified() && !ip.is_unicast_link_local()),
}
};
if let std::net::SocketAddr::V6(address) = &mut source_address {
if address.ip().is_unicast_link_local() && address.scope_id() == 0 {
address.set_scope_id(interface.index);
}
}
GatewayBinding::new(
endpoint,
source_address,
interface.name.clone(),
interface.index,
ClientAddresses { ipv4, ipv6 },
fingerprint.clone(),
)
}
// Default-route inventories include scoped, backup, and unrelated address-family
// routes. Attribute each actual destination by its selected source instead.
fn physical_interface_for_source(
interfaces: &[Interface],
source: SocketAddr,
endpoint: SocketAddr,
) -> anyhow::Result<&Interface> {
let mut scope = None;
for address in [source, endpoint] {
if let SocketAddr::V6(address) = address {
if address.scope_id() != 0 {
ensure!(
scope.is_none_or(|scope| scope == address.scope_id()),
"Network source and destination have different interface scopes"
);
scope = Some(address.scope_id());
}
}
}
let source = source.ip();
ensure!(
!source.is_unspecified() && !source.is_loopback(),
"Network route has no physical source address"
);
let mut matches = interfaces.iter().filter(|interface| {
scope.is_none_or(|scope| scope == interface.index)
&& (interface.ipv4.iter().any(|ip| IpAddr::V4(ip.addr()) == source)
|| interface.ipv6.iter().any(|ip| IpAddr::V6(ip.addr()) == source))
});
let interface = matches
.next()
.context("Network route has no matching physical interface")?;
ensure!(
matches.next().is_none(),
"Network route has ambiguous physical interfaces"
);
ensure!(
matches!(
interface.if_type,
netdev::prelude::InterfaceType::Ethernet
| netdev::prelude::InterfaceType::Wireless80211
| netdev::prelude::InterfaceType::FastEthernetT
| netdev::prelude::InterfaceType::FastEthernetFx
| netdev::prelude::InterfaceType::GigabitEthernet
),
"Network route uses an unsupported physical interface: {}",
interface.name
);
Ok(interface)
}
fn resolver_endpoint(server: &str, interface: Option<&str>, interfaces: &[Interface]) -> anyhow::Result<SocketAddr> {
let (address, zone) = server
.split_once('%')
.map_or((server, None), |(ip, zone)| (ip, Some(zone)));
let ip: IpAddr = address.parse().context("Invalid resolver address")?;
let mut endpoint = SocketAddr::new(ip, 53);
if let SocketAddr::V6(address) = &mut endpoint {
let zone = if zone.is_none() && address.ip().is_unicast_link_local() {
interface
} else {
zone
};
if let Some(zone) = zone {
let index = interfaces
.iter()
.find(|candidate| candidate.name == zone || candidate.index.to_string() == zone)
.context("Resolver IPv6 zone has no matching interface")?
.index;
address.set_scope_id(index);
}
ensure!(
!address.ip().is_unicast_link_local() || address.scope_id() != 0,
"Link-local resolver has no interface scope"
);
} else {
ensure!(zone.is_none(), "IPv4 resolver cannot have an interface scope");
}
Ok(endpoint)
}
async fn inspect(cancellation: CancellationToken) -> anyhow::Result<NetworkSnapshot> {
tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(INSPECTION_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"Network inspection cancelled",
));
}
budget.check()
};
let result = snapshot(&netdev::get_interfaces(), &check)?;
check()?;
Ok(result)
})
.await?
}
fn literal_gateway_address(origin: &url::Url) -> anyhow::Result<Option<IpAddr>> {
Ok(match origin.host().context("Gateway host is missing")? {
url::Host::Ipv4(ip) => Some(IpAddr::V4(ip)),
url::Host::Ipv6(ip) => Some(IpAddr::V6(ip)),
url::Host::Domain(_) => None,
})
}
fn snapshot(interfaces: &[Interface], control: &dyn CollectionControl) -> anyhow::Result<NetworkSnapshot> {
control.check()?;
Ok(NetworkSnapshot {
interfaces: interfaces.iter().map(InterfaceIdentity::from).collect(),
routes: platform::routes(control)?.into_iter().collect(),
resolvers: platform::resolvers(control)?,
})
}
fn command(name: &str, args: &[&str], control: &dyn CollectionControl) -> anyhow::Result<String> {
let output = CollectorCommands::new(control)
.run(name, args)?
.with_context(|| format!("Required network tool {name} is unavailable"))?;
ensure!(output.status.success(), "Network tool {name} failed");
String::from_utf8(output.stdout).context("Network tool output is not UTF-8")
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
fn resolv_conf(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
control.check()?;
let file = std::fs::File::open("/etc/resolv.conf")?;
use std::io::Read;
let mut contents = String::new();
file.take(64 * 1024 + 1).read_to_string(&mut contents)?;
ensure!(contents.len() <= 64 * 1024, "Resolver configuration is too large");
control.check()?;
Ok(vec![parse_resolv_conf(&contents)?])
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
fn parse_resolv_conf(contents: &str) -> anyhow::Result<ResolverContext> {
let mut resolver = ResolverContext {
interface: None,
servers: Vec::new(),
domains: Vec::new(),
};
for line in contents.lines() {
let line = line.split(['#', ';']).next().unwrap_or_default();
let mut fields = line.split_whitespace();
match fields.next() {
Some("nameserver") => {
if let Some(server) = fields.next() {
// IPv6 zone identifiers are retained for scoped physical resolvers.
server
.split('%')
.next()
.unwrap_or_default()
.parse::<IpAddr>()
.context("Invalid resolver address")?;
resolver.servers.push(server.to_owned());
}
}
Some("search" | "domain") => resolver
.domains
.extend(fields.map(|domain| domain.to_ascii_lowercase())),
_ => {}
}
}
Ok(resolver)
}
#[cfg(test)]
mod tests {
use super::*;
fn ethernet(name: &str, index: u32, address: &str) -> Interface {
let mut interface = Interface::dummy();
interface.name = name.into();
interface.index = index;
interface.if_type = netdev::prelude::InterfaceType::Ethernet;
interface.ipv4 = vec![address.parse().unwrap()];
interface.ipv6 = vec!["fe80::1/64".parse().unwrap()];
interface
}
#[test]
fn attributes_each_destination_without_requiring_a_single_uplink() {
let ethernet = ethernet("en0", 7, "192.0.2.10/24");
let mut wifi = ethernet.clone();
wifi.name = "en1".into();
wifi.index = 8;
wifi.if_type = netdev::prelude::InterfaceType::Wireless80211;
wifi.ipv4 = vec!["198.51.100.10/24".parse().unwrap()];
let mut tunnel = Interface::dummy();
tunnel.name = "utun0".into();
tunnel.index = 9;
tunnel.ipv4 = vec!["10.0.0.1/24".parse().unwrap()];
let interfaces = [ethernet, wifi, tunnel];
for (source, endpoint, expected) in [
("192.0.2.10:0", "203.0.113.1:443", "en0"),
("198.51.100.10:0", "198.51.100.53:53", "en1"),
("[fe80::1%8]:0", "[fe80::53%8]:53", "en1"),
] {
assert_eq!(
physical_interface_for_source(&interfaces, source.parse().unwrap(), endpoint.parse().unwrap())
.unwrap()
.name,
expected
);
}
// Virtual interfaces may coexist, but must never supply the selected source.
assert!(
physical_interface_for_source(
&interfaces,
"10.0.0.1:0".parse().unwrap(),
"10.0.0.53:53".parse().unwrap()
)
.is_err()
);
// Identical link-local addresses without scope are ambiguous.
assert!(
physical_interface_for_source(
&interfaces,
"[fe80::1]:0".parse().unwrap(),
"[fe80::53]:53".parse().unwrap()
)
.is_err()
);
assert!(
physical_interface_for_source(
&interfaces,
"[fe80::1%7]:0".parse().unwrap(),
"[fe80::53%8]:53".parse().unwrap()
)
.is_err()
);
}
#[test]
fn rejects_ambiguous_or_unattributed_sources() {
let interfaces = [ethernet("en0", 7, "192.0.2.10/24"), ethernet("en1", 8, "192.0.2.10/24")];
for source in ["192.0.2.10:0", "192.0.2.11:0", "127.0.0.1:0", "0.0.0.0:0"] {
assert!(
physical_interface_for_source(&interfaces, source.parse().unwrap(), "192.0.2.53:53".parse().unwrap()).is_err()
);
}
}
#[test]
fn resolver_zones_support_native_names_and_numeric_indices() {
let interfaces = [ethernet("en0", 7, "192.0.2.10/24")];
let expected: SocketAddr = "[fe80::53%7]:53".parse().unwrap();
assert_eq!(resolver_endpoint("fe80::53%en0", None, &interfaces).unwrap(), expected);
assert_eq!(resolver_endpoint("fe80::53%7", None, &interfaces).unwrap(), expected);
assert_eq!(
resolver_endpoint("fe80::53", Some("en0"), &interfaces).unwrap(),
expected
);
assert_eq!(
resolver_endpoint("192.0.2.53", Some("en0"), &interfaces).unwrap(),
"192.0.2.53:53".parse().unwrap()
);
for server in ["fe80::53", "fe80::53%missing", "fe80::53%8", "192.0.2.53%en0"] {
assert!(
resolver_endpoint(server, None, &interfaces).is_err(),
"accepted {server}"
);
}
}
#[test]
fn bracketed_ipv6_gateway_is_a_literal_endpoint() {
let origin = super::super::transport::gateway_origin("https://[2001:db8::1]:444").unwrap();
assert_eq!(
literal_gateway_address(&origin).unwrap(),
Some("2001:db8::1".parse().unwrap())
);
}
#[test]
fn resolver_order_comments_and_case_do_not_change_network_identity() {
assert_eq!(
parse_resolv_conf("nameserver 192.0.2.53\nsearch CORP.EXAMPLE\n# comment").unwrap(),
parse_resolv_conf("search corp.example\nnameserver 192.0.2.53 # DHCP\n").unwrap()
);
assert_ne!(
parse_resolv_conf("nameserver 192.0.2.53").unwrap(),
parse_resolv_conf("nameserver 192.0.2.54").unwrap()
);
}
#[test]
fn interface_identity_ignores_counters_and_address_enumeration_order() {
let mut interface = Interface::dummy();
interface.index = 7;
interface.name = "bridge0".into();
interface.ipv4 = vec!["192.0.2.10/24".parse().unwrap(), "192.0.2.11/24".parse().unwrap()];
let original = InterfaceIdentity::from(&interface);
interface.ipv4.reverse();
interface.mtu = Some(1200);
interface.default = !interface.default;
assert_eq!(original, InterfaceIdentity::from(&interface));
interface.index = 8;
assert_ne!(original, InterfaceIdentity::from(&interface));
}
}
#[cfg(test)]
pub(crate) fn test_binding() -> GatewayBinding {
GatewayBinding::new(
"192.0.2.10:443".parse().unwrap(),
"192.0.2.5:0".parse().unwrap(),
"fixture".into(),
1,
ClientAddresses {
ipv4: Some("192.0.2.5".parse().unwrap()),
ipv6: None,
},
"0".repeat(64),
)
.unwrap()
}
-245
View File
@@ -1,245 +0,0 @@
use std::{net::SocketAddr, path::PathBuf};
use anyhow::{Context, ensure};
use dns_lookup::{AddrFamily, AddrInfoHints, SockType, getaddrinfo};
use tokio_util::sync::CancellationToken;
use super::*;
const MAX_ADDRESSES: usize = 64;
#[doc(hidden)]
pub fn detect_in_helper(address: std::net::IpAddr, hostname: &str) -> anyhow::Result<bool> {
super::detection::validate_target(address, hostname)?;
Ok(dns_lookup::lookup_addr(&address).is_ok_and(|name| name.eq_ignore_ascii_case(hostname)))
}
pub(super) async fn detect(
address: std::net::IpAddr,
hostname: &str,
cancellation: &CancellationToken,
) -> anyhow::Result<bool> {
super::detection::validate_target(address, hostname)?;
let args = vec![
"detect-internal-host".into(),
"--address".into(),
address.to_string(),
"--hostname".into(),
hostname.into(),
];
let output = run_helper(common::binary_paths::gpclient(), args, cancellation.clone()).await?;
serde_json::from_slice(&output).context("Invalid internal detection helper response")
}
/// Entry point for gpclient's isolated native resolver helper. This blocking
/// function must run in the child process, never a connection runtime thread.
#[doc(hidden)]
pub fn lookup_in_helper(host: &str, port: u16, disable_ipv6: bool) -> anyhow::Result<Vec<SocketAddr>> {
validate_host(host, port)?;
let hints = AddrInfoHints {
address: if disable_ipv6 { AddrFamily::Inet.into() } else { 0 },
socktype: SockType::Stream.into(),
..AddrInfoHints::default()
};
let service = port.to_string();
let mut addresses = Vec::new();
for result in getaddrinfo(Some(host), Some(&service), Some(hints)).map_err(io::Error::from)? {
let address = result?.sockaddr;
if !addresses.contains(&address) {
ensure!(
addresses.len() < MAX_ADDRESSES,
"Native resolver returned too many gateway addresses"
);
addresses.push(address);
}
}
validate_addresses(&addresses, port, disable_ipv6)?;
Ok(addresses)
}
pub(super) async fn resolve(
host: &str,
port: u16,
disable_ipv6: bool,
cancellation: &CancellationToken,
) -> anyhow::Result<Vec<SocketAddr>> {
validate_host(host, port)?;
let mut args = vec!["resolve-gateway".into(), host.into(), "--port".into(), port.to_string()];
if disable_ipv6 {
args.push("--disable-ipv6".into());
}
run_resolver(
common::binary_paths::gpclient(),
args,
port,
disable_ipv6,
cancellation.clone(),
)
.await
}
async fn run_resolver(
executable: PathBuf,
args: Vec<String>,
port: u16,
disable_ipv6: bool,
cancellation: CancellationToken,
) -> anyhow::Result<Vec<SocketAddr>> {
let output = run_helper(executable, args, cancellation).await?;
let addresses: Vec<SocketAddr> = serde_json::from_slice(&output).context("Invalid resolver helper response")?;
validate_addresses(&addresses, port, disable_ipv6)?;
Ok(addresses)
}
async fn run_helper(
executable: PathBuf,
args: Vec<String>,
cancellation: CancellationToken,
) -> anyhow::Result<Vec<u8>> {
// Await the owned worker even on cancellation. CollectorCommands kills and
// waits for the helper process and any descendants before returning.
tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(INSPECTION_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(
io::ErrorKind::Interrupted,
"Gateway resolution cancelled",
));
}
budget.check()
};
let args = args.iter().map(String::as_str).collect::<Vec<_>>();
let output = CollectorCommands::new(&check)
.run_executable(&executable, &args)?
.context("Native resolver helper is unavailable")?;
check()?;
ensure!(output.status.success(), "Native gateway resolution failed");
Ok(output.stdout)
})
.await?
}
fn validate_host(host: &str, port: u16) -> anyhow::Result<()> {
ensure!(port != 0, "Gateway port is zero");
ensure!(
!host.is_empty() && host.len() <= 253 && !host.contains('\0') && !host.contains(['/', ':']),
"Invalid gateway hostname"
);
Ok(())
}
fn validate_addresses(addresses: &[SocketAddr], port: u16, disable_ipv6: bool) -> anyhow::Result<()> {
ensure!(
!addresses.is_empty() && addresses.len() <= MAX_ADDRESSES,
"Invalid gateway address count"
);
ensure!(
addresses.iter().all(|address| {
address.port() == port && !address.ip().is_unspecified() && (!disable_ipv6 || address.is_ipv4())
}),
"Invalid gateway address from resolver helper"
);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn actual_helper_output_is_validated_before_admission() {
let addresses = run_resolver(
"/bin/sh".into(),
vec!["-c".into(), "printf '[\"192.0.2.1:443\"]'".into()],
443,
true,
CancellationToken::new(),
)
.await
.unwrap();
assert_eq!(addresses, vec!["192.0.2.1:443".parse::<SocketAddr>().unwrap()]);
assert!(
run_resolver(
"/bin/sh".into(),
vec!["-c".into(), "printf '[\"192.0.2.1:444\"]'".into()],
443,
true,
CancellationToken::new(),
)
.await
.is_err()
);
}
#[tokio::test]
async fn cancellation_kills_and_joins_the_running_resolver_process() {
let file = tempfile::NamedTempFile::new().unwrap();
let path = file.path().to_owned();
let cancellation = CancellationToken::new();
let worker = tokio::spawn(run_resolver(
"/bin/sh".into(),
vec![
"-c".into(),
"printf '%s' \"$$\" > \"$1\"; sleep 30 & wait".into(),
"resolver-test".into(),
path.to_string_lossy().into_owned(),
],
443,
false,
cancellation.clone(),
));
let pid = tokio::time::timeout(Duration::from_secs(2), async {
loop {
if let Ok(pid) = std::fs::read_to_string(&path).unwrap().parse::<i32>() {
break pid;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
cancellation.cancel();
let error = tokio::time::timeout(Duration::from_secs(1), worker)
.await
.unwrap()
.unwrap()
.unwrap_err();
assert_eq!(
error.downcast::<io::Error>().unwrap().kind(),
io::ErrorKind::Interrupted
);
assert_eq!(
nix::sys::signal::kill(nix::unistd::Pid::from_raw(pid), None),
Err(nix::errno::Errno::ESRCH)
);
}
#[test]
fn native_lookup_preserves_port_and_ipv4_policy() {
let addresses = lookup_in_helper("localhost", 444, true).unwrap();
assert!(
addresses
.iter()
.all(|address| address.is_ipv4() && address.ip().is_loopback() && address.port() == 444)
);
}
#[test]
fn helper_response_validation_retains_ipv6_scope_and_rejects_wrong_port() {
let addresses = vec!["[fe80::1%7]:443".parse().unwrap(), "192.0.2.1:443".parse().unwrap()];
validate_addresses(&addresses, 443, false).unwrap();
assert_eq!(
serde_json::from_str::<Vec<SocketAddr>>(&serde_json::to_string(&addresses).unwrap()).unwrap(),
addresses
);
assert!(validate_addresses(&addresses, 444, false).is_err());
assert!(validate_addresses(&addresses, 443, true).is_err());
}
#[test]
fn rejects_invalid_helper_requests_before_lookup() {
assert!(lookup_in_helper("gateway.example/path", 443, false).is_err());
assert!(lookup_in_helper("gateway.example", 0, false).is_err());
}
}
-316
View File
@@ -1,316 +0,0 @@
use std::{
future::Future,
io,
pin::Pin,
sync::{Arc, Mutex},
time::{Duration, Instant},
};
use tokio::task::JoinSet;
use tokio_util::sync::CancellationToken;
use zeroize::{Zeroize, Zeroizing};
use crate::{gateway::Gateway, process::collection::CollectionControl};
use super::{
GatewaySession, GatewaySessionSummary, GatewaySessions, InternalSessionPolicy, MaintenanceState, SessionEndReason,
SessionMode, transport::GatewayRequestError,
};
const COLLECTION_TIMEOUT: Duration = Duration::from_secs(60);
/// This request is deliberately independent of OpenConnect's callback/FFI types.
#[derive(Clone)]
pub struct SessionHipRequest {
pub gateway: Gateway,
pub cookie: String,
pub client_ip: Option<String>,
pub client_ipv6: Option<String>,
pub md5: String,
pub collect_posture: bool,
}
impl Drop for SessionHipRequest {
fn drop(&mut self) {
self.cookie.zeroize();
}
}
pub struct SessionCollectionControl {
cancellation: CancellationToken,
deadline: Instant,
}
impl CollectionControl for SessionCollectionControl {
fn check(&self) -> io::Result<()> {
if self.cancellation.is_cancelled() {
Err(io::Error::new(io::ErrorKind::Interrupted, "HIP collection cancelled"))
} else if Instant::now() >= self.deadline {
Err(io::Error::new(io::ErrorKind::TimedOut, "HIP collection timed out"))
} else {
Ok(())
}
}
}
pub type SessionReportProducer =
dyn Fn(&SessionHipRequest, &SessionCollectionControl) -> io::Result<String> + Send + Sync;
pub type SessionReportObserver = dyn Fn(&SessionHipRequest, &str) + Send + Sync;
pub type SessionStatusObserver = dyn Fn(GatewaySessionSummary) + Send + Sync;
pub type SessionNetworkValidator =
dyn Fn(CancellationToken) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send>> + Send + Sync;
#[derive(Clone)]
pub struct SessionCallbacks {
pub produce_report: Arc<SessionReportProducer>,
pub report_submitted: Arc<SessionReportObserver>,
pub status_changed: Arc<SessionStatusObserver>,
pub validate_network: Arc<SessionNetworkValidator>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SessionExit {
Disconnected,
Failed(SessionEndReason),
}
/// Owns maintenance workers until they have stopped. The session owner retains
/// its ledger and logs out after joining every worker. Interactive authentication
/// also belongs to that owner. Cancel and await this future, never abort/drop it:
/// blocking collectors must finish before cleanup releases their resources.
pub async fn maintain_non_tunnel_sessions(
sessions: &mut GatewaySessions,
policy: InternalSessionPolicy,
mut callbacks: SessionCallbacks,
cancellation: CancellationToken,
network_change: impl Future<Output = SessionEndReason>,
) -> anyhow::Result<SessionExit> {
anyhow::ensure!(!sessions.is_empty(), "Non-tunnel session set is empty");
anyhow::ensure!(
sessions
.members()
.iter()
.all(|session| session.transport.authentication().mode() == SessionMode::NonTunnel),
"Tunnel member supplied to non-tunnel runtime"
);
let workers_cancel = cancellation.child_token();
let observer = callbacks.status_changed.clone();
let status_gate = Arc::new(Mutex::new(()));
let gate = status_gate.clone();
let cancelled = workers_cancel.clone();
let worker_observer = observer.clone();
callbacks.status_changed = Arc::new(move |summary| {
let _guard = gate.lock().unwrap_or_else(|error| error.into_inner());
if !cancelled.is_cancelled() {
worker_observer(summary);
}
});
let mut workers = JoinSet::new();
for session in sessions.members() {
let session = session.clone();
let callbacks = callbacks.clone();
let cancellation = workers_cancel.clone();
workers.spawn(async move {
let server = session.gateway.server().to_owned();
(server, maintain_member(session, policy, callbacks, cancellation).await)
});
}
tokio::pin!(network_change);
let mut worker_failure = None;
let outcome = loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => break SessionExit::Disconnected,
reason = &mut network_change => break SessionExit::Failed(reason),
result = workers.join_next() => match result {
Some(Ok((_, MemberExit::Terminal(reason)))) => break SessionExit::Failed(reason),
Some(Ok((server, MemberExit::Rejected))) => {
sessions.logout_gateway(&server).await;
if workers.is_empty() { break SessionExit::Failed(SessionEndReason::AllMembersFailed); }
},
Some(Ok((_, MemberExit::Cancelled))) => {},
Some(Err(error)) => { worker_failure = Some(error); break SessionExit::Disconnected; },
None => break SessionExit::Failed(SessionEndReason::AllMembersFailed),
},
}
};
workers_cancel.cancel();
if matches!(outcome, SessionExit::Failed(_)) || worker_failure.is_some() {
// Invalidate advertised health before waiting for collectors or remote
// cleanup. Cancellation prevents workers from publishing Healthy afterwards.
let _guard = status_gate.lock().unwrap_or_else(|error| error.into_inner());
for session in sessions.members() {
observer(GatewaySessionSummary {
gateway: session.gateway.clone(),
mode: SessionMode::NonTunnel,
client_ip: session.addresses.ipv4.map(|ip| ip.to_string()),
client_ipv6: session.addresses.ipv6.map(|ip| ip.to_string()),
maintenance: MaintenanceState::Rejected,
});
}
}
// Do not abort workers: a blocking collector must observe cancellation and be
// joined before approval/identity resources can be released by the caller.
while let Some(result) = workers.join_next().await {
if let Err(error) = result {
worker_failure.get_or_insert(error);
}
}
if let Some(error) = worker_failure {
return Err(error.into());
}
// Deliberate disconnect wins even when it arrives during coordinated cleanup.
if cancellation.is_cancelled() {
Ok(SessionExit::Disconnected)
} else {
Ok(outcome)
}
}
async fn maintain_member(
session: Arc<GatewaySession>,
policy: InternalSessionPolicy,
callbacks: SessionCallbacks,
cancellation: CancellationToken,
) -> MemberExit {
let request = SessionHipRequest {
gateway: session.gateway.clone(),
cookie: session.transport.authentication().cookie().into(),
client_ip: session.addresses.ipv4.map(|ip| ip.to_string()),
client_ipv6: session.addresses.ipv6.map(|ip| ip.to_string()),
md5: session.transport.hip_token(),
collect_posture: policy.collect_hip_data(),
};
let status = |maintenance| {
if !cancellation.is_cancelled() {
(callbacks.status_changed)(GatewaySessionSummary {
gateway: session.gateway.clone(),
mode: SessionMode::NonTunnel,
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
maintenance,
});
}
};
status(MaintenanceState::Authenticated);
loop {
if (callbacks.validate_network)(cancellation.clone()).await.is_err() {
return MemberExit::Terminal(SessionEndReason::NetworkChanged);
}
let sent_at = tokio::time::Instant::now();
let check = tokio::select! {
biased;
_ = cancellation.cancelled() => return MemberExit::Cancelled,
result = session.transport.check_hip(session.addresses.ipv4.map(Into::into), session.addresses.ipv6.map(Into::into)) => result,
};
let (result, delay) = match check {
Ok(check) => {
let result = if check.report_needed {
collect_and_submit(&session, &request, &callbacks, &cancellation).await
} else {
Ok(())
};
(result, check.delay)
}
Err(error) => (Err(MemberError::Gateway(error)), Duration::ZERO),
};
let next_check = match result {
Ok(()) => {
if cancellation.is_cancelled() {
return MemberExit::Cancelled;
}
status(MaintenanceState::Healthy);
let Some(next_check) = sent_at
.checked_add(policy.hip_interval())
.and_then(|time| time.checked_add(delay))
else {
status(MaintenanceState::Rejected);
return MemberExit::Rejected;
};
next_check
}
Err(MemberError::Gateway(GatewayRequestError::InvalidCookie)) => {
status(MaintenanceState::Rejected);
return MemberExit::Terminal(SessionEndReason::InvalidCookie);
}
Err(MemberError::Network) => return MemberExit::Terminal(SessionEndReason::NetworkChanged),
Err(MemberError::Authorization) => return MemberExit::Terminal(SessionEndReason::AuthorizationRevoked),
Err(error) => {
if cancellation.is_cancelled() {
return MemberExit::Cancelled;
}
status(MaintenanceState::Rejected);
log::warn!("Gateway maintenance failed: {error}");
return MemberExit::Rejected;
}
};
tokio::select! {
biased;
_ = cancellation.cancelled() => return MemberExit::Cancelled,
_ = tokio::time::sleep_until(next_check) => {},
}
}
}
enum MemberExit {
Cancelled,
Rejected,
Terminal(SessionEndReason),
}
#[derive(Debug, thiserror::Error)]
enum MemberError {
#[error("{0}")]
Gateway(#[from] GatewayRequestError),
// Collector/script errors can contain user-provided text. Do not log payloads.
#[error("HIP report collection failed")]
Collection,
#[error("Physical network validation failed")]
Network,
#[error("HIP report authorization was revoked")]
Authorization,
}
async fn collect_and_submit(
session: &GatewaySession,
request: &SessionHipRequest,
callbacks: &SessionCallbacks,
cancellation: &CancellationToken,
) -> Result<(), MemberError> {
let producer = callbacks.produce_report.clone();
let input = request.clone();
let control = SessionCollectionControl {
cancellation: cancellation.clone(),
deadline: Instant::now() + COLLECTION_TIMEOUT,
};
let report = tokio::task::spawn_blocking(move || {
control.check()?;
let report = Zeroizing::new(producer(&input, &control)?);
control.check()?;
Ok::<_, io::Error>(report)
})
.await
.map_err(|_| MemberError::Collection)?
.map_err(|error| {
if error.kind() == io::ErrorKind::PermissionDenied {
MemberError::Authorization
} else {
MemberError::Collection
}
})?;
(callbacks.validate_network)(cancellation.clone())
.await
.map_err(|_| MemberError::Network)?;
tokio::select! {
biased;
_ = cancellation.cancelled() => return Err(MemberError::Collection),
result = session.transport.submit_hip(&report, session.addresses.ipv4.map(Into::into), session.addresses.ipv6.map(Into::into)) => result?,
}
if !cancellation.is_cancelled() {
(callbacks.report_submitted)(request, &report);
}
Ok(())
}
#[cfg(test)]
mod tests;
@@ -1,415 +0,0 @@
use std::{
future::pending,
sync::{
Mutex,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
};
use tokio::sync::Notify;
use super::*;
use crate::session::transport::GatewayTransport;
use crate::session::{
ClientAddresses, GatewaySessions,
transport::tests::{gateway, response},
};
async fn run_owned_sessions(
members: Vec<GatewaySession>,
policy: InternalSessionPolicy,
callbacks: SessionCallbacks,
cancellation: CancellationToken,
network_change: impl Future<Output = SessionEndReason>,
) -> anyhow::Result<SessionExit> {
let mut sessions = GatewaySessions::new(members);
let result =
maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation.clone(), network_change).await;
sessions.logout().await;
if cancellation.is_cancelled() {
Ok(SessionExit::Disconnected)
} else {
result
}
}
fn member(name: &str, transport: GatewayTransport) -> GatewaySession {
GatewaySession {
gateway: Gateway::new(name.into(), format!("{name}.example")),
transport,
addresses: ClientAddresses {
ipv4: Some("192.0.2.7".parse().unwrap()),
ipv6: None,
},
}
}
fn callbacks() -> SessionCallbacks {
SessionCallbacks {
produce_report: Arc::new(|_, _| Ok("<hip-report/>".into())),
report_submitted: Arc::new(|_, _| {}),
status_changed: Arc::new(|_| {}),
validate_network: Arc::new(|_| Box::pin(async { Ok(()) })),
}
}
#[tokio::test]
async fn network_uncertainty_prevents_hip_and_healthy_status() {
let (transport, server) = gateway(vec![response("<response status='success'/>")]).await;
let mut callbacks = callbacks();
callbacks.validate_network = Arc::new(|_| Box::pin(async { anyhow::bail!("Network changed") }));
callbacks.status_changed = Arc::new(|summary| assert_ne!(summary.maintenance, MaintenanceState::Healthy));
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::NetworkChanged));
assert_eq!(server.await.unwrap()[0].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn revoked_report_authorization_terminates_the_attempt() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
callbacks.produce_report = Arc::new(|_, _| Err(io::ErrorKind::PermissionDenied.into()));
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::AuthorizationRevoked));
assert_eq!(server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn invalid_cookie_terminates_only_after_logout() {
let (transport, server) = gateway(vec![
response("<response status='error'><error>Invalid authentication cookie</error></response>"),
response("<response status='success'/>"),
])
.await;
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks(),
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::InvalidCookie));
let requests = server.await.unwrap();
assert_eq!(requests.len(), 2);
assert_eq!(requests[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn rejection_preserves_healthy_members_and_cleanup_owns_all_members() {
let (rejected, rejected_server) = gateway(vec![
response("<response status='error'><error>Denied</error></response>"),
response("<response status='success'/>"),
])
.await;
let (healthy, healthy_server) = gateway(vec![
response("<response><hip-report-needed>no</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let ready = Arc::new(Notify::new());
let states = Arc::new(Mutex::new(Vec::new()));
let mut callbacks = callbacks();
let states_copy = states.clone();
let ready_copy = ready.clone();
callbacks.status_changed = Arc::new(move |summary| {
if summary.maintenance != MaintenanceState::Authenticated {
let mut states = states_copy.lock().unwrap();
states.push((summary.gateway.name().to_owned(), summary.maintenance));
if states.len() == 2 {
ready_copy.notify_one();
}
}
});
let exit = run_owned_sessions(
vec![member("rejected", rejected), member("healthy", healthy)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
async {
ready.notified().await;
SessionEndReason::NetworkChanged
},
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::NetworkChanged));
let states = states.lock().unwrap();
assert!(states.contains(&("rejected".into(), MaintenanceState::Rejected)));
assert!(states.contains(&("healthy".into(), MaintenanceState::Healthy)));
assert_eq!(rejected_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
assert_eq!(healthy_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn observes_reports_only_after_successful_submission() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
response("<response status='success'/>"),
])
.await;
let cancellation = CancellationToken::new();
let submitted = Arc::new(AtomicUsize::new(0));
let observed = submitted.clone();
let stop = cancellation.clone();
let mut callbacks = callbacks();
callbacks.report_submitted = Arc::new(move |request, report| {
assert_eq!(request.client_ip.as_deref(), Some("192.0.2.7"));
assert_eq!(report, "<hip-report/>");
observed.fetch_add(1, Ordering::SeqCst);
stop.cancel();
});
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
cancellation,
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Disconnected);
assert_eq!(submitted.load(Ordering::SeqCst), 1);
assert_eq!(server.await.unwrap().len(), 3);
}
#[tokio::test]
async fn cancelled_collection_is_joined_before_runtime_returns() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let cancellation = CancellationToken::new();
let entered = Arc::new(Notify::new());
let stopped = Arc::new(AtomicBool::new(false));
let mut callbacks = callbacks();
let entered_copy = entered.clone();
let stopped_copy = stopped.clone();
callbacks.produce_report = Arc::new(move |_, control| {
entered_copy.notify_one();
loop {
if let Err(error) = control.check() {
stopped_copy.store(true, Ordering::SeqCst);
return Err(error);
}
std::thread::sleep(Duration::from_millis(10));
}
});
callbacks.report_submitted = Arc::new(|_, _| panic!("Cancelled report must not be observed"));
let stop = cancellation.clone();
let exit = tokio::time::timeout(
Duration::from_secs(2),
run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
cancellation,
async {
entered.notified().await;
stop.cancel();
pending().await
},
),
)
.await
.unwrap()
.unwrap();
assert_eq!(exit, SessionExit::Disconnected);
assert!(stopped.load(Ordering::SeqCst));
assert_eq!(server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn all_rejected_members_are_logged_out_before_terminal_failure() {
let (transport, server) = gateway(vec![
response("<response status='error'><error>Denied</error></response>"),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
callbacks.produce_report = Arc::new(|_, _| panic!("Rejected member cannot collect a report"));
let exit = run_owned_sessions(
vec![member("rejected", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::AllMembersFailed));
assert_eq!(server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn invalid_member_cookie_cancels_and_joins_another_members_collector() {
let arrived = Arc::new(Notify::new());
let release = Arc::new(Notify::new());
let collecting = Arc::new(Notify::new());
let stopped = Arc::new(AtomicBool::new(false));
let (expired, expired_server) = crate::session::transport::tests::gateway_with_first_response_gate(
vec![
response("<response status='error'><error>Invalid authentication cookie</error></response>"),
response("<response status='success'/>"),
],
arrived.clone(),
release.clone(),
)
.await;
let (healthy, healthy_server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
let collecting_copy = collecting.clone();
let stopped_copy = stopped.clone();
callbacks.produce_report = Arc::new(move |request, control| {
assert_eq!(request.gateway.name(), "collecting");
collecting_copy.notify_one();
loop {
if let Err(error) = control.check() {
stopped_copy.store(true, Ordering::SeqCst);
return Err(error);
}
std::thread::sleep(Duration::from_millis(10));
}
});
callbacks.report_submitted = Arc::new(|_, _| panic!("Interrupted collection must not submit"));
let exit = tokio::time::timeout(
Duration::from_secs(2),
run_owned_sessions(
vec![member("expired", expired), member("collecting", healthy)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
async {
arrived.notified().await;
collecting.notified().await;
release.notify_one();
pending().await
},
),
)
.await
.unwrap()
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::InvalidCookie));
assert!(stopped.load(Ordering::SeqCst));
assert_eq!(expired_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
assert_eq!(healthy_server.await.unwrap()[1].0, "/ssl-vpn/logout.esp");
}
#[tokio::test]
async fn failed_submission_is_terminal_without_retry_or_observation() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed></response>"),
"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_owned(),
response("<response status='success'/>"),
])
.await;
let mut callbacks = callbacks();
callbacks.report_submitted = Arc::new(|_, _| panic!("Failed report must not be retained"));
let exit = run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::default(),
callbacks,
CancellationToken::new(),
pending(),
)
.await
.unwrap();
assert_eq!(exit, SessionExit::Failed(SessionEndReason::AllMembersFailed));
let requests = server.await.unwrap();
assert_eq!(
requests.iter().map(|request| request.0.as_str()).collect::<Vec<_>>(),
[
"/ssl-vpn/hipreportcheck.esp",
"/ssl-vpn/hipreport.esp",
"/ssl-vpn/logout.esp"
]
);
}
#[tokio::test]
async fn schedules_from_send_time_plus_interval_and_server_delay() {
let arrived = Arc::new(Notify::new());
let release = Arc::new(Notify::new());
let (transport, server) = crate::session::transport::tests::gateway_with_first_response_gate(
vec![
response("<response><hip-report-needed>no</hip-report-needed><delay>7</delay></response>"),
response("<response><hip-report-needed>no</hip-report-needed></response>"),
response("<response status='success'/>"),
],
arrived.clone(),
release.clone(),
)
.await;
let cancellation = CancellationToken::new();
let stop = cancellation.clone();
let (sent, mut received) = tokio::sync::mpsc::unbounded_channel();
let mut callbacks = callbacks();
callbacks.status_changed = Arc::new(move |summary| {
if summary.maintenance == MaintenanceState::Healthy {
sent.send(tokio::time::Instant::now()).unwrap();
}
});
let runtime = tokio::spawn(run_owned_sessions(
vec![member("internal", transport)],
InternalSessionPolicy::new(10, false).unwrap(),
callbacks,
cancellation,
pending(),
));
arrived.notified().await;
// Simulate three seconds spent waiting for the first response. The interval
// must be anchored before that latency, rather than after completion.
tokio::time::pause();
tokio::time::advance(Duration::from_secs(3)).await;
tokio::time::resume();
release.notify_one();
let first = received.recv().await.unwrap();
tokio::time::pause();
tokio::time::advance(Duration::from_secs(13)).await;
tokio::time::resume();
tokio::time::sleep(Duration::from_millis(20)).await;
assert!(received.try_recv().is_err(), "Server delay must extend the interval");
tokio::time::pause();
tokio::time::advance(Duration::from_secs(1)).await;
tokio::time::resume();
let second = tokio::time::timeout(Duration::from_millis(500), received.recv())
.await
.unwrap()
.unwrap();
let elapsed = second.duration_since(first);
assert!(
elapsed >= Duration::from_millis(13_900) && elapsed < Duration::from_millis(14_500),
"Unexpected anchored interval: {elapsed:?}"
);
stop.cancel();
assert_eq!(runtime.await.unwrap().unwrap(), SessionExit::Disconnected);
assert_eq!(server.await.unwrap().len(), 3);
}
-335
View File
@@ -1,335 +0,0 @@
use std::{net::IpAddr, time::Duration};
use reqwest::{Client, StatusCode, Url, redirect::Policy};
use xmltree::Element;
use crate::{gp_params::GpParams, os_profile::OsProfile, utils::xml::ElementExt};
use super::{GatewayAuthentication, network::GatewayBinding};
const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
pub(crate) const MAX_GATEWAY_RESPONSE_BYTES: usize = 1024 * 1024;
pub const MAX_HIP_REPORT_BYTES: usize = 1024 * 1024;
#[derive(Debug, thiserror::Error)]
pub enum GatewayRequestError {
#[error("Gateway authentication cookie expired")]
InvalidCookie,
#[error("Gateway request failed: {0}")]
Transport(#[from] reqwest::Error),
#[error("Gateway returned HTTP {0}")]
Http(StatusCode),
#[error("Gateway rejected the request")]
Rejected,
#[error("Gateway returned a malformed response")]
MalformedResponse,
#[error("Gateway response exceeds its size limit")]
ResponseTooLarge,
#[error("HIP report is empty, contains NUL, or exceeds its size limit")]
InvalidReport,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HipCheck {
pub report_needed: bool,
pub delay: Duration,
}
/// Authenticated HTTP requests retain the login identity. Non-tunnel maintenance
/// uses a validated physical binding; pre-tunnel cleanup uses ordinary HTTP.
pub struct GatewayTransport {
client: Client,
origin: Url,
authentication: GatewayAuthentication,
profile: OsProfile,
}
impl GatewayTransport {
pub fn new(
server: &str,
authentication: GatewayAuthentication,
params: &GpParams,
binding: Option<&GatewayBinding>,
) -> anyhow::Result<Self> {
let origin = Url::parse(&crate::utils::normalize_server(server)?)?;
let client = match binding {
Some(binding) => bound_client(server, params, binding)?,
None => Client::try_from(params)?,
};
Ok(Self {
client,
origin,
authentication,
profile: params.os_profile().clone(),
})
}
/// The login client already validated and built this transport before issuing
/// authentication. Registering its cleanup context cannot fail afterwards.
pub(crate) fn from_authenticated_login(
client: Client,
origin: Url,
authentication: GatewayAuthentication,
profile: OsProfile,
) -> Self {
Self {
client,
origin,
authentication,
profile,
}
}
pub fn authentication(&self) -> &GatewayAuthentication {
&self.authentication
}
pub fn hip_token(&self) -> String {
hip_token(self.authentication.cookie())
}
pub async fn check_hip(&self, ipv4: Option<IpAddr>, ipv6: Option<IpAddr>) -> Result<HipCheck, GatewayRequestError> {
let mut form = self.hip_form(ipv4, ipv6);
form.push(("md5".into(), self.hip_token()));
parse_hip_check(&self.post("hipreportcheck.esp", &form).await?)
}
pub async fn submit_hip(
&self,
report: &str,
ipv4: Option<IpAddr>,
ipv6: Option<IpAddr>,
) -> Result<(), GatewayRequestError> {
if report.is_empty() || report.len() > MAX_HIP_REPORT_BYTES || report.contains('\0') {
return Err(GatewayRequestError::InvalidReport);
}
let mut form = self.hip_form(ipv4, ipv6);
form.push(("report".into(), report.into()));
self.post("hipreport.esp", &form).await?;
Ok(())
}
pub async fn logout(&self) -> Result<(), GatewayRequestError> {
logout_cookie(&self.client, &self.origin, self.authentication.cookie(), &self.profile).await
}
fn cookie_form(&self) -> Vec<(String, String)> {
url::form_urlencoded::parse(self.authentication.cookie().as_bytes())
.into_owned()
.collect()
}
fn hip_form(&self, ipv4: Option<IpAddr>, ipv6: Option<IpAddr>) -> Vec<(String, String)> {
let mut form = self.cookie_form();
set_form(&mut form, "client-role", "global-protect-full");
set_form(&mut form, "computer", self.profile.computer());
set_form(&mut form, "host-id", self.profile.host_id());
set_form(&mut form, "serialno", self.profile.serialno());
if let Some(ip) = ipv4 {
set_form(&mut form, "client-ip", &ip.to_string());
}
if let Some(ip) = ipv6 {
set_form(&mut form, "client-ipv6", &ip.to_string());
}
form
}
async fn post(&self, endpoint: &str, form: &[(String, String)]) -> Result<Element, GatewayRequestError> {
post(&self.client, &self.origin, endpoint, form).await
}
}
/// Cleanup uses trustworthy issued cookie fields even when execution mode is
/// invalid. It never creates a runnable authentication with a fabricated mode.
pub(crate) async fn logout_cookie(
client: &Client,
origin: &Url,
cookie: &str,
profile: &OsProfile,
) -> Result<(), GatewayRequestError> {
let mut form = url::form_urlencoded::parse(cookie.as_bytes()).into_owned().collect();
set_form(&mut form, "computer", profile.computer());
set_form(&mut form, "clientos", profile.client_os().as_str());
set_form(&mut form, "os-version", profile.os_version());
post(client, origin, "logout.esp", &form).await?;
Ok(())
}
async fn post(
client: &Client,
origin: &Url,
endpoint: &str,
form: &[(String, String)],
) -> Result<Element, GatewayRequestError> {
let mut url = origin.clone();
url.set_path(&format!("/ssl-vpn/{endpoint}"));
let response = client.post(url).form(form).send().await?;
let status = response.status();
let invalid_cookie = status.as_u16() == 512
|| response
.headers()
.get("x-private-pan-globalprotect")
.is_some_and(|value| value == "Invalid authentication cookie");
if invalid_cookie {
return Err(GatewayRequestError::InvalidCookie);
}
if !status.is_success() {
return Err(GatewayRequestError::Http(status));
}
let body = crate::utils::request::read_bounded_response(response, MAX_GATEWAY_RESPONSE_BYTES)
.await
.map_err(|error| match error {
crate::utils::request::ResponseBodyError::Transport(error) => GatewayRequestError::Transport(error),
crate::utils::request::ResponseBodyError::TooLarge => GatewayRequestError::ResponseTooLarge,
})?;
parse_response(&body)
}
pub(crate) fn bound_client(server: &str, params: &GpParams, binding: &GatewayBinding) -> anyhow::Result<Client> {
binding.validate_server(server)?;
let origin = gateway_origin(server)?;
let host = origin
.host_str()
.ok_or_else(|| anyhow::anyhow!("Gateway host is missing"))?;
let builder = params
.client_builder()?
.redirect(Policy::none())
.no_proxy()
.local_address(binding.source().ip())
.resolve(host, binding.endpoint())
.timeout(REQUEST_TIMEOUT);
let builder = bind_interface(builder, binding)?;
Ok(builder.build()?)
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) -> anyhow::Result<reqwest::ClientBuilder> {
Ok(builder.interface(binding.interface()))
}
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) -> anyhow::Result<reqwest::ClientBuilder> {
if let std::net::SocketAddr::V6(source) = binding.source() {
anyhow::ensure!(
source.scope_id() == 0,
"Scoped IPv6 source requires a native socket connector"
);
}
Ok(builder)
}
pub(crate) fn gateway_origin(server: &str) -> anyhow::Result<Url> {
let server = if server.starts_with("https://") {
server.to_owned()
} else {
format!("https://{server}")
};
let origin = Url::parse(&server)?;
anyhow::ensure!(
origin.scheme() == "https"
&& origin.username().is_empty()
&& origin.password().is_none()
&& origin.path() == "/"
&& origin.query().is_none()
&& origin.fragment().is_none(),
"Gateway endpoint must be an HTTPS origin"
);
Ok(origin)
}
fn set_form(form: &mut Vec<(String, String)>, key: &str, value: &str) {
form.retain(|(name, _)| name != key);
form.push((key.into(), value.into()));
}
/// Match gpst.c::build_csd_token without decoding or reordering cookie fields.
pub fn hip_token(cookie: &str) -> String {
let stable = cookie
.split('&')
.filter(|field| {
let key = field.split('=').next().unwrap_or_default();
!matches!(key, "authcookie" | "preferred-ip" | "preferred-ipv6")
})
.collect::<Vec<_>>()
.join("&");
format!("{:x}", md5::compute(stable.as_bytes()))
}
fn parse_response(body: &[u8]) -> Result<Element, GatewayRequestError> {
let text = std::str::from_utf8(body).map_err(|_| GatewayRequestError::MalformedResponse)?;
let lower = text.to_ascii_lowercase();
if lower.contains("<!doctype") || lower.contains("<!entity") {
return Err(GatewayRequestError::MalformedResponse);
}
if let Some(error) = javascript_error(text) {
return Err(error);
}
let root = Element::parse(body).map_err(|_| GatewayRequestError::MalformedResponse)?;
if root.name == "html" {
return Err(
root
.descendant_text("body")
.as_deref()
.and_then(javascript_error)
.unwrap_or(GatewayRequestError::MalformedResponse),
);
}
if root.name == "prelogin-response" && root.child_text("status").as_deref() == Some("Error") {
return Err(message_error(root.child_text("msg").as_deref()));
}
if root.name != "response" {
return Err(GatewayRequestError::MalformedResponse);
}
match root.attr("status") {
Some("error") => Err(message_error(root.child_text("error").as_deref())),
None | Some("success") => Ok(root),
_ => Err(GatewayRequestError::Rejected),
}
}
fn message_error(message: Option<&str>) -> GatewayRequestError {
if message == Some("Invalid authentication cookie") {
GatewayRequestError::InvalidCookie
} else {
GatewayRequestError::Rejected
}
}
fn javascript_error(text: &str) -> Option<GatewayRequestError> {
static ERROR: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
let regex = ERROR.get_or_init(|| {
regex::Regex::new(r#"(?s)^\s*var\s+respStatus\s*=\s*"Error"\s*;\s*var\s+respMsg\s*=\s*("(?:\\.|[^"\\])*")"#)
.expect("valid GlobalProtect error pattern")
});
let captures = regex.captures(text)?;
match serde_json::from_str::<String>(&captures[1]) {
Ok(message) => Some(message_error(Some(&message))),
Err(_) => Some(GatewayRequestError::MalformedResponse),
}
}
fn parse_hip_check(root: &Element) -> Result<HipCheck, GatewayRequestError> {
let report_needed = match root.child_text("hip-report-needed").as_deref() {
Some("yes") => true,
Some("no") => false,
_ => return Err(GatewayRequestError::MalformedResponse),
};
let delay = match root.child_text("delay") {
Some(value) => value
.parse::<u32>()
.map_err(|_| GatewayRequestError::MalformedResponse)?,
None => 0,
};
// Limit this client's supported response delay to one hour. The official
// registry scheduling cap is not evidence of a wire-protocol maximum.
if delay > 3600 {
return Err(GatewayRequestError::MalformedResponse);
}
Ok(HipCheck {
report_needed,
delay: Duration::from_secs(u64::from(delay)),
})
}
#[cfg(test)]
pub(crate) mod tests;
-246
View File
@@ -1,246 +0,0 @@
use super::*;
use tokio::{
io::{AsyncReadExt, AsyncWriteExt},
net::TcpListener,
task::JoinHandle,
};
pub(crate) async fn gateway(responses: Vec<String>) -> (GatewayTransport, JoinHandle<Vec<(String, String)>>) {
gateway_fixture(responses, None).await
}
pub(crate) async fn login_gateway(responses: Vec<String>) -> (Client, Url, JoinHandle<Vec<(String, String)>>) {
let (transport, server) = gateway(responses).await;
(transport.client, transport.origin, server)
}
pub(crate) async fn gateway_with_first_response_gate(
responses: Vec<String>,
arrived: std::sync::Arc<tokio::sync::Notify>,
release: std::sync::Arc<tokio::sync::Notify>,
) -> (GatewayTransport, JoinHandle<Vec<(String, String)>>) {
gateway_fixture(responses, Some((arrived, release))).await
}
async fn gateway_fixture(
responses: Vec<String>,
gate: Option<(std::sync::Arc<tokio::sync::Notify>, std::sync::Arc<tokio::sync::Notify>)>,
) -> (GatewayTransport, JoinHandle<Vec<(String, String)>>) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let origin = Url::parse(&format!("http://{}", listener.local_addr().unwrap())).unwrap();
let server = tokio::spawn(async move {
let mut requests = Vec::new();
for (index, response) in responses.into_iter().enumerate() {
let (mut stream, _) = listener.accept().await.unwrap();
let mut bytes = Vec::new();
let (headers_end, length) = loop {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).await.unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
if let Some(position) = bytes.windows(4).position(|part| part == b"\r\n\r\n") {
let headers = std::str::from_utf8(&bytes[..position]).unwrap();
let length = headers
.lines()
.find_map(|line| {
let (key, value) = line.split_once(':')?;
key
.eq_ignore_ascii_case("content-length")
.then(|| value.trim().parse::<usize>().unwrap())
})
.unwrap();
break (position + 4, length);
}
};
while bytes.len() < headers_end + length {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).await.unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
}
let path = std::str::from_utf8(&bytes[..headers_end])
.unwrap()
.split_whitespace()
.nth(1)
.unwrap()
.to_owned();
let body = String::from_utf8(bytes[headers_end..headers_end + length].to_vec()).unwrap();
requests.push((path, body));
if index == 0
&& let Some((arrived, release)) = &gate
{
arrived.notify_one();
release.notified().await;
}
stream.write_all(response.as_bytes()).await.unwrap();
}
requests
});
let transport = GatewayTransport {
client: Client::builder()
.redirect(Policy::none())
.no_proxy()
.timeout(REQUEST_TIMEOUT)
.build()
.unwrap(),
origin,
authentication: GatewayAuthentication::new(
"authcookie=test-cookie&portal=portal&user=alice&domain=example&computer=test".into(),
"non-tunnel".into(),
)
.unwrap(),
profile: OsProfile::builder(crate::os_profile::ClientOs::Linux)
.computer_name_override("test")
.build(),
};
(transport, server)
}
pub(crate) fn response(body: &str) -> String {
format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
}
#[test]
fn checksum_matches_c_protocol_golden_fixture() {
for volatile in [
"authcookie=test&preferred-ip=192.0.2.1&preferred-ipv6=2001%3Adb8%3A%3A1",
"authcookie=refreshed&preferred-ip=192.0.2.2&preferred-ipv6=2001%3Adb8%3A%3A2",
] {
let cookie =
format!("user=test&{volatile}&persistent-cookie=persistent%2Bcookie&portal=test&domain=test&computer=test");
assert_eq!(hip_token(&cookie), "20f30054f721fd212925866b5778447d");
}
assert_ne!(hip_token("user=alice%20bob"), hip_token("user=alice+bob"));
assert_ne!(hip_token("user=alice&portal=a"), hip_token("portal=a&user=alice"));
}
#[tokio::test]
async fn maintenance_uses_only_hip_and_logout_with_physical_identity() {
let (transport, server) = gateway(vec![
response("<response><hip-report-needed>yes</hip-report-needed><delay>7</delay></response>"),
response("<response status='success'/>"),
response("<response status='success'/>"),
])
.await;
let ipv4 = Some("192.0.2.7".parse().unwrap());
let ipv6 = Some("2001:db8::7".parse().unwrap());
let check = transport.check_hip(ipv4, ipv6).await.unwrap();
assert_eq!(
check,
HipCheck {
report_needed: true,
delay: Duration::from_secs(7)
}
);
transport.submit_hip("<hip-report/>", ipv4, ipv6).await.unwrap();
transport.logout().await.unwrap();
let requests = server.await.unwrap();
assert_eq!(
requests.iter().map(|(path, _)| path.as_str()).collect::<Vec<_>>(),
[
"/ssl-vpn/hipreportcheck.esp",
"/ssl-vpn/hipreport.esp",
"/ssl-vpn/logout.esp"
]
);
let form: std::collections::HashMap<String, String> = serde_urlencoded::from_str(&requests[0].1).unwrap();
assert_eq!(form["authcookie"], "test-cookie");
assert_eq!(form["client-ip"], "192.0.2.7");
assert_eq!(form["client-ipv6"], "2001:db8::7");
assert_eq!(form["md5"], transport.hip_token());
}
#[tokio::test]
async fn rejects_redirects_without_forwarding_authentication() {
let destination = TcpListener::bind("127.0.0.1:0").await.unwrap();
let (transport, server) = gateway(vec![format!(
"HTTP/1.1 307 Temporary Redirect\r\nLocation: http://{}/stolen\r\nContent-Length: 0\r\nConnection: close\r\n\r\n",
destination.local_addr().unwrap()
)])
.await;
assert!(
matches!(transport.check_hip(None, None).await, Err(GatewayRequestError::Http(status)) if status.as_u16() == 307)
);
assert!(
tokio::time::timeout(Duration::from_millis(100), destination.accept())
.await
.is_err()
);
assert_eq!(server.await.unwrap().len(), 1);
}
#[tokio::test]
async fn distinguishes_expired_cookie_from_transport_and_protocol_errors() {
let (transport, server) = gateway(vec![
response("<response status='error'><error>Invalid authentication cookie</error></response>"),
"HTTP/1.1 512 Invalid Cookie\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(),
"HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".into(),
response("<response><hip-report-needed>maybe</hip-report-needed></response>"),
response("<response status='error'><error>server-private-payload</error></response>"),
])
.await;
for _ in 0..2 {
assert!(matches!(
transport.check_hip(None, None).await,
Err(GatewayRequestError::InvalidCookie)
));
}
assert!(matches!(
transport.check_hip(None, None).await.unwrap_err(),
GatewayRequestError::Http(StatusCode::SERVICE_UNAVAILABLE)
));
assert!(matches!(
transport.check_hip(None, None).await,
Err(GatewayRequestError::MalformedResponse)
));
let error = transport.check_hip(None, None).await.unwrap_err();
assert!(!format!("{error:?}").contains("server-private-payload"));
server.await.unwrap();
}
#[tokio::test]
async fn bounds_response_size_before_reading_body() {
let (transport, server) = gateway(vec![format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
MAX_GATEWAY_RESPONSE_BYTES + 1
)])
.await;
assert!(matches!(
transport.check_hip(None, None).await,
Err(GatewayRequestError::ResponseTooLarge)
));
server.await.unwrap();
}
#[test]
fn rejects_invalid_delays_and_unsafe_response_xml() {
for delay in ["-1", "3601", "4294967296", "invalid"] {
let root = parse_response(
format!("<response><hip-report-needed>no</hip-report-needed><delay>{delay}</delay></response>").as_bytes(),
)
.unwrap();
assert!(parse_hip_check(&root).is_err());
}
assert!(parse_response(b"<!DOCTYPE response><response/>").is_err());
}
#[test]
fn recognizes_cookie_expiry_in_official_error_formats() {
for body in [
r#"var respStatus = "Error"; var respMsg = "Invalid authentication\u0020cookie"; thisForm.inputStr.value = "";"#,
r#"<html><head/><body>var respStatus = "Error"; var respMsg = "Invalid authentication cookie";</body></html>"#,
"<prelogin-response><status>Error</status><msg>Invalid authentication cookie</msg></prelogin-response>",
] {
assert!(matches!(
parse_response(body.as_bytes()),
Err(GatewayRequestError::InvalidCookie)
));
}
assert!(matches!(
parse_response(b"<response status='error'><error>Denied</error></response>"),
Err(GatewayRequestError::Rejected)
));
}
+40 -1
View File
@@ -1,14 +1,53 @@
use std::collections::HashMap;
use std::env;
use std::ffi::OsStr;
use std::io::Write;
use std::path::Path;
use log::info;
use tempfile::NamedTempFile;
pub fn persist_env_vars(extra: Option<HashMap<String, String>>) -> anyhow::Result<NamedTempFile> {
let mut env_file = NamedTempFile::new()?;
let content = env::vars()
.map(|(key, value)| format!("{}={}", key, value))
.chain(
extra
.unwrap_or_default()
.into_iter()
.map(|(key, value)| format!("{}={}", key, value)),
)
.collect::<Vec<String>>()
.join("\n");
writeln!(env_file, "{}", content)?;
Ok(env_file)
}
pub fn load_env_vars<T: AsRef<Path>>(env_file: T) -> anyhow::Result<HashMap<String, String>> {
let content = std::fs::read_to_string(env_file)?;
let mut env_vars: HashMap<String, String> = HashMap::new();
for line in content.lines() {
if let Some((key, value)) = line.split_once('=') {
env_vars.insert(key.to_string(), value.to_string());
}
}
Ok(env_vars)
}
pub fn patch_gui_runtime_env(hidpi: bool) {
// This is to avoid blank screen on some systems
unsafe { std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1") };
if is_wayland_session(
env::var_os("WAYLAND_DISPLAY").as_deref(),
env::var("XDG_SESSION_TYPE").ok().as_deref(),
) {
info!("Wayland session detected, enabling software GL");
info!("Wayland session detected, enabling Linux WebKit rendering fallbacks");
set_env_if_missing("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
set_env_if_missing("LIBGL_ALWAYS_SOFTWARE", "1");
}
Loaded 100 of 142 files, more files were not shown because too many files have changed in this diff. Show more