mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 06:06:13 -05:00
Compare commits
18
Commits
main
...
feat/windows-nsh
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4e6a3ab553 | ||
|
|
976fcd5adc | ||
|
|
b7450ecae3 | ||
|
|
ed306bdbdc | ||
|
|
e22aa64ba6 | ||
|
|
5b17706ff1 | ||
|
|
6e72eb19e1 | ||
|
|
78afa8fd14 | ||
|
|
0f85b259cd | ||
|
|
343ed3b1e5 | ||
|
|
42f4aebbde | ||
|
|
df28072f60 | ||
|
|
de9656fcd2 | ||
|
|
87fdcc76b3 | ||
|
|
8d768f4584 | ||
|
|
b84712b038 | ||
|
|
cf715ea38f | ||
|
|
560d2b2de7 |
No files matched your search
@@ -0,0 +1,2 @@
|
||||
# Keep source and build scripts consistent on every platform.
|
||||
* text=auto eol=lf
|
||||
@@ -0,0 +1,186 @@
|
||||
name: Build Windows package
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
gp_ref:
|
||||
type: string
|
||||
required: true
|
||||
gpgui_ref:
|
||||
type: string
|
||||
required: true
|
||||
channel:
|
||||
type: choice
|
||||
options: [snapshot, stable]
|
||||
default: snapshot
|
||||
build:
|
||||
type: string
|
||||
required: true
|
||||
architecture:
|
||||
type: choice
|
||||
options: [x64, arm64]
|
||||
required: true
|
||||
workflow_call:
|
||||
inputs:
|
||||
gp_ref:
|
||||
type: string
|
||||
required: true
|
||||
gpgui_ref:
|
||||
type: string
|
||||
required: true
|
||||
channel:
|
||||
type: string
|
||||
required: true
|
||||
build:
|
||||
type: string
|
||||
required: true
|
||||
architecture:
|
||||
type: string
|
||||
required: true
|
||||
secrets:
|
||||
GH_PAT:
|
||||
required: true
|
||||
WINDOWS_UPDATE_PRIVATE_KEY:
|
||||
required: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ${{ inputs.architecture == 'arm64' && 'windows-11-arm' || 'windows-2022' }}
|
||||
timeout-minutes: 120
|
||||
env:
|
||||
BUILD_ARCHITECTURE: ${{ inputs.architecture }}
|
||||
CARGO_INCREMENTAL: '0'
|
||||
CARGO_TARGET_DIR: ${{ github.workspace }}/target-windows
|
||||
CARGO_BUILD_JOBS: '2'
|
||||
GPGUI_UPDATE_CHANNEL: ${{ inputs.channel }}
|
||||
GPGUI_BUILD_VERSION: ${{ inputs.channel == 'snapshot' && inputs.build || '' }}
|
||||
GPGUI_WINDOWS_UPDATE_PUBLIC_KEY: ${{ vars.WINDOWS_UPDATE_PUBLIC_KEY }}
|
||||
GPGUI_LICENSE_SIGNING_KEYS: ${{ vars.GPGUI_LICENSE_SIGNING_KEYS }}
|
||||
steps:
|
||||
- name: Select native build tools
|
||||
id: native
|
||||
shell: pwsh
|
||||
run: |
|
||||
if ($env:BUILD_ARCHITECTURE -eq 'arm64') {
|
||||
'msystem=CLANGARM64' >> $env:GITHUB_OUTPUT
|
||||
'subsystem=clangarm64' >> $env:GITHUB_OUTPUT
|
||||
'packages=mingw-w64-clang-aarch64-clang mingw-w64-clang-aarch64-pkgconf mingw-w64-clang-aarch64-gnutls mingw-w64-clang-aarch64-libxml2 mingw-w64-clang-aarch64-lz4' >> $env:GITHUB_OUTPUT
|
||||
} elseif ($env:BUILD_ARCHITECTURE -eq 'x64') {
|
||||
'msystem=UCRT64' >> $env:GITHUB_OUTPUT
|
||||
'subsystem=ucrt64' >> $env:GITHUB_OUTPUT
|
||||
'packages=mingw-w64-ucrt-x86_64-gcc mingw-w64-ucrt-x86_64-pkgconf mingw-w64-ucrt-x86_64-gnutls mingw-w64-ucrt-x86_64-libxml2 mingw-w64-ucrt-x86_64-lz4' >> $env:GITHUB_OUTPUT
|
||||
} else { throw 'Unsupported Windows architecture.' }
|
||||
- uses: actions/checkout@v6
|
||||
with:
|
||||
path: .ci
|
||||
persist-credentials: false
|
||||
- uses: actions/checkout@v6
|
||||
with:
|
||||
ref: ${{ inputs.gp_ref }}
|
||||
path: source/gp
|
||||
submodules: recursive
|
||||
persist-credentials: false
|
||||
- uses: ./.ci/.github/actions/checkout-private
|
||||
with:
|
||||
token: ${{ secrets.GH_PAT }}
|
||||
ref: ${{ inputs.gpgui_ref }}
|
||||
path: source/gpgui
|
||||
- uses: dtolnay/[email protected]
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: '3.13'
|
||||
- uses: msys2/setup-msys2@v2
|
||||
id: msys2
|
||||
with:
|
||||
msystem: ${{ steps.native.outputs.msystem }}
|
||||
update: true
|
||||
install: >-
|
||||
base-devel autoconf automake libtool gettext git
|
||||
${{ steps.native.outputs.packages }}
|
||||
- name: Prepare pinned installer and driver inputs
|
||||
shell: pwsh
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
if (!$env:GPGUI_WINDOWS_UPDATE_PUBLIC_KEY -or !$env:GPGUI_LICENSE_SIGNING_KEYS) { throw 'Configure the Windows update and licensing public keys.' }
|
||||
$tools = Join-Path $env:RUNNER_TEMP 'windows-tools'
|
||||
New-Item -ItemType Directory -Force $tools | Out-Null
|
||||
choco install nsis --version=3.12.0 --yes --no-progress
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Installing NSIS 3.12 failed.' }
|
||||
$wintun = Join-Path $tools 'wintun.zip'
|
||||
Invoke-WebRequest 'https://www.wintun.net/builds/wintun-0.14.1.zip' -OutFile $wintun
|
||||
if ((Get-FileHash $wintun).Hash -ne '07C256185D6EE3652E09FA55C0B673E2624B565E02C4B9091C79CA7D2F24EF51') { throw 'Wintun checksum mismatch.' }
|
||||
Expand-Archive $wintun $tools
|
||||
Remove-Item $wintun
|
||||
"WINDOWS_BUILD_TOOLS=$tools" >> $env:GITHUB_ENV
|
||||
- name: Build OpenConnect and test native packet transport
|
||||
shell: pwsh
|
||||
env:
|
||||
MSYS_ROOT: ${{ steps.msys2.outputs.msys2-location }}
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$prefix = Join-Path $env:RUNNER_TEMP 'native-windows'
|
||||
& ./source/gp/scripts/build-openconnect-windows.ps1 -MsysRoot $env:MSYS_ROOT -MsysSubsystem ${{ steps.native.outputs.subsystem }} -Prefix $prefix
|
||||
& ./source/gp/scripts/test-openconnect-windows.ps1 -MsysRoot $env:MSYS_ROOT -MsysSubsystem ${{ steps.native.outputs.subsystem }} -Prefix $prefix
|
||||
"OPENCONNECT_WINDOWS_PREFIX=$prefix" >> $env:GITHUB_ENV
|
||||
- name: Build and package the matching Windows runtime
|
||||
shell: pwsh
|
||||
env:
|
||||
MSYS_ROOT: ${{ steps.msys2.outputs.msys2-location }}
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$log = Join-Path $env:RUNNER_TEMP 'windows-package.log'
|
||||
# Compiler diagnostics may contain private GUI source. Keep them on the runner.
|
||||
try {
|
||||
& ./source/gpgui/scripts/build-windows.ps1 -Profile Release `
|
||||
-NativePrefix $env:OPENCONNECT_WINDOWS_PREFIX -MsysRoot $env:MSYS_ROOT -MsysSubsystem ${{ steps.native.outputs.subsystem }} `
|
||||
-WintunDirectory (Join-Path $env:WINDOWS_BUILD_TOOLS 'wintun') `
|
||||
-MakeNsis (Join-Path ${env:ProgramFiles(x86)} 'NSIS/makensis.exe') `
|
||||
-OutputDirectory "$env:GITHUB_WORKSPACE/artifacts" *> $log
|
||||
} catch {
|
||||
python ./.ci/scripts/private-ci-diagnostics.py compile $log
|
||||
throw 'Windows compilation or packaging failed; private diagnostics remain on the runner.'
|
||||
}
|
||||
Write-Host 'Windows compilation and packaging passed.'
|
||||
- name: Sign and verify update payload
|
||||
id: sign
|
||||
shell: pwsh
|
||||
env:
|
||||
UPDATE_PRIVATE_KEY: ${{ secrets.WINDOWS_UPDATE_PRIVATE_KEY }}
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$key = Join-Path $env:RUNNER_TEMP 'windows-update.key'
|
||||
try {
|
||||
[IO.File]::WriteAllText($key, $env:UPDATE_PRIVATE_KEY.Trim())
|
||||
. ./source/gpgui/scripts/windows-updates/Get-WinSparkle.ps1
|
||||
$tools = Get-WinSparkleTools "$env:GITHUB_WORKSPACE/artifacts/tools" -Architecture $env:BUILD_ARCHITECTURE
|
||||
$installer = @(Get-ChildItem artifacts -Filter '*-setup.exe')
|
||||
if ($installer.Count -ne 1) { throw 'Expected exactly one Windows installer.' }
|
||||
$signature = (& $tools.Tool sign -f $key $installer[0].FullName | Out-String).Trim()
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Windows update signing failed.' }
|
||||
& $tools.Tool verify -p $env:GPGUI_WINDOWS_UPDATE_PUBLIC_KEY -s $signature $installer[0].FullName
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Windows update signature verification failed.' }
|
||||
$signature | Set-Content ($installer[0].FullName + '.sig') -Encoding ascii
|
||||
} finally {
|
||||
Remove-Item $key -Force -ErrorAction SilentlyContinue
|
||||
Remove-Item artifacts/tools -Recurse -Force -ErrorAction SilentlyContinue
|
||||
}
|
||||
- name: Test native installer and uninstaller
|
||||
shell: pwsh
|
||||
run: |
|
||||
$installer = @(Get-ChildItem artifacts -Filter '*-setup.exe')
|
||||
if ($installer.Count -ne 1) { throw 'Expected exactly one Windows installer.' }
|
||||
& ./source/gp/scripts/test-windows-installer.ps1 -Installer $installer[0].FullName -Architecture $env:BUILD_ARCHITECTURE -Build $env:GPGUI_BUILD_VERSION
|
||||
- uses: actions/upload-artifact@v7
|
||||
if: ${{ !cancelled() && steps.sign.outcome == 'success' }}
|
||||
with:
|
||||
name: artifact-gpgui-windows-${{ inputs.architecture }}
|
||||
path: |
|
||||
artifacts/*.exe
|
||||
artifacts/*.exe.sig
|
||||
artifacts/*.exe.sha256
|
||||
overwrite: true
|
||||
if-no-files-found: error
|
||||
retention-days: 7
|
||||
@@ -42,6 +42,11 @@ on:
|
||||
required: true
|
||||
default: false
|
||||
type: boolean
|
||||
build_windows:
|
||||
description: 'Build Windows x64 and ARM64 NSH installers'
|
||||
required: true
|
||||
default: false
|
||||
type: boolean
|
||||
push:
|
||||
paths-ignore:
|
||||
- LICENSE
|
||||
@@ -465,6 +470,24 @@ jobs:
|
||||
secrets:
|
||||
GH_PAT: ${{ secrets.GH_PAT }}
|
||||
|
||||
build-windows:
|
||||
needs: validate-inputs
|
||||
if: ${{ (github.event_name == 'workflow_dispatch' && inputs.build_windows) || (startsWith(github.ref, 'refs/tags/') && vars.BUILD_WINDOWS_ON_TAG == 'true') }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
architecture: [x64, arm64]
|
||||
uses: ./.github/workflows/build-windows.yaml
|
||||
with:
|
||||
architecture: ${{ matrix.architecture }}
|
||||
gp_ref: ${{ needs.validate-inputs.outputs.gp_sha }}
|
||||
gpgui_ref: ${{ needs.validate-inputs.outputs.gpgui_sha }}
|
||||
channel: ${{ github.event_name == 'workflow_dispatch' && inputs.channel || 'stable' }}
|
||||
build: ${{ format('{0}.{1}', github.run_number, github.run_attempt) }}
|
||||
secrets:
|
||||
GH_PAT: ${{ secrets.GH_PAT }}
|
||||
WINDOWS_UPDATE_PRIVATE_KEY: ${{ secrets.WINDOWS_UPDATE_PRIVATE_KEY }}
|
||||
|
||||
nix-source:
|
||||
needs: [validate-inputs, build-gpgui-glibc]
|
||||
strategy:
|
||||
@@ -1191,6 +1214,7 @@ jobs:
|
||||
- build-gpgui-glibc
|
||||
- build-gpgui-musl
|
||||
- build-gpgui-nsh
|
||||
- build-windows
|
||||
- setup-bsd-matrix
|
||||
- build-gpgui-frontend
|
||||
- build-bsd
|
||||
@@ -1201,6 +1225,7 @@ jobs:
|
||||
NEEDS_JSON: ${{ toJson(needs) }}
|
||||
BSD_MATRIX_ENABLED: ${{ needs.setup-bsd-matrix.outputs.enabled }}
|
||||
IS_STABLE: ${{ (startsWith(github.ref, 'refs/tags/') || (github.event_name == 'workflow_dispatch' && inputs.channel == 'stable')) }}
|
||||
BUILD_WINDOWS: ${{ (github.event_name == 'workflow_dispatch' && inputs.build_windows) || (startsWith(github.ref, 'refs/tags/') && vars.BUILD_WINDOWS_ON_TAG == 'true') }}
|
||||
run: |
|
||||
python3 - <<'PY'
|
||||
import json
|
||||
@@ -1220,6 +1245,8 @@ jobs:
|
||||
continue
|
||||
elif name in {"build-gpgui-frontend", "build-bsd"} and result == "skipped" and not bsd_matrix_enabled:
|
||||
continue
|
||||
elif name == "build-windows" and result == "skipped" and os.environ["BUILD_WINDOWS"] != "true":
|
||||
continue
|
||||
elif result == "skipped":
|
||||
failed.append(f"{name}: {result}")
|
||||
|
||||
|
||||
@@ -34,6 +34,10 @@ on:
|
||||
highlights:
|
||||
required: false
|
||||
type: string
|
||||
unix_snapshot_build:
|
||||
description: Verified Unix snapshot build when it differs from the macOS retry
|
||||
required: false
|
||||
type: string
|
||||
unix_platforms:
|
||||
required: false
|
||||
default: linux,freebsd,openbsd
|
||||
@@ -75,6 +79,10 @@ on:
|
||||
description: Stable release highlights, one per line
|
||||
required: false
|
||||
type: string
|
||||
unix_snapshot_build:
|
||||
description: Verified Unix snapshot build; omit when it matches the macOS build
|
||||
required: false
|
||||
type: string
|
||||
unix_platforms:
|
||||
description: Comma-separated Unix platforms with published assets (linux,freebsd,openbsd)
|
||||
required: true
|
||||
@@ -104,6 +112,7 @@ jobs:
|
||||
SPARKLE_VERSION: 2.9.2
|
||||
UPDATE_HIGHLIGHTS: ${{ inputs.highlights }}
|
||||
UNIX_PLATFORMS: ${{ inputs.unix_platforms }}
|
||||
UNIX_SNAPSHOT_BUILD: ${{ inputs.unix_snapshot_build }}
|
||||
SPARKLE_ARCHIVE_SHA256: b83e37436774556ed055e0244b297ef2c790e0737393bf65bf495fcbba6eed65
|
||||
steps:
|
||||
- name: Validate inputs
|
||||
@@ -126,6 +135,12 @@ jobs:
|
||||
echo "unix_platforms must list published Unix targets separated by commas" >&2
|
||||
exit 1
|
||||
fi
|
||||
if [[ -n "$UNIX_SNAPSHOT_BUILD" ]]; then
|
||||
if [[ "$CHANNEL" != "snapshot" || ! "$UNIX_SNAPSHOT_BUILD" =~ ^(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*)){0,2}$ ]]; then
|
||||
echo "unix_snapshot_build requires a snapshot channel and one to three numeric components" >&2
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
if [[ "$CHANNEL" == "snapshot" && "$RELEASE_TAG" != "snapshot" ]]; then
|
||||
echo "The snapshot channel must publish to the snapshot release" >&2
|
||||
exit 1
|
||||
@@ -344,6 +359,7 @@ jobs:
|
||||
echo "short_version=$short_version" >> "$GITHUB_OUTPUT"
|
||||
|
||||
- name: Prepare Unix update manifest
|
||||
id: unix_manifest
|
||||
env:
|
||||
RELEASED_AT: ${{ steps.release.outputs.released_at }}
|
||||
run: |
|
||||
@@ -384,7 +400,8 @@ jobs:
|
||||
else
|
||||
printf 'Development snapshot after %s.\n' \
|
||||
"${{ steps.bundle.outputs.short_version }}" > "$highlights"
|
||||
generate_args+=(--build "${{ steps.bundle.outputs.version }}")
|
||||
unix_build="${UNIX_SNAPSHOT_BUILD:-${{ steps.bundle.outputs.version }}}"
|
||||
generate_args+=(--build "$unix_build")
|
||||
released_at="$(date -u +%F)"
|
||||
fi
|
||||
|
||||
@@ -393,6 +410,9 @@ jobs:
|
||||
--released-at "$released_at" \
|
||||
--highlights-file "$highlights" \
|
||||
--output "$manifest"
|
||||
if [[ "$CHANNEL" == "snapshot" ]]; then
|
||||
echo "build=$unix_build" >> "$GITHUB_OUTPUT"
|
||||
fi
|
||||
|
||||
- name: Fetch current appcast
|
||||
id: current-appcast
|
||||
@@ -528,6 +548,13 @@ jobs:
|
||||
--channel "$CHANNEL" \
|
||||
--archive-url "https://github.com/$REPOSITORY/releases/download/$RELEASE_TAG/$ARCHIVE_NAME"
|
||||
|
||||
- name: Preserve other platform feeds
|
||||
run: |
|
||||
python3 scripts/preserve-update-feeds.py \
|
||||
--base-url "${FEED_URL%/appcast.xml}" \
|
||||
--directory gpgui/apps/update-feed-worker/public \
|
||||
--exclude appcast.xml --exclude latest.json
|
||||
|
||||
- name: Deploy update feed worker
|
||||
env:
|
||||
CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
|
||||
@@ -581,7 +608,7 @@ jobs:
|
||||
--version "${{ steps.bundle.outputs.short_version }}"
|
||||
)
|
||||
if [[ "$CHANNEL" == "snapshot" ]]; then
|
||||
expected+=(--build "${{ steps.bundle.outputs.version }}")
|
||||
expected+=(--build "${{ steps.unix_manifest.outputs.build }}")
|
||||
fi
|
||||
for _ in 1 2 3 4 5 6 7 8 9 10; do
|
||||
if curl --fail --location --silent --show-error \
|
||||
|
||||
@@ -0,0 +1,162 @@
|
||||
name: Publish Windows update feed
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
inputs:
|
||||
gpgui_ref:
|
||||
description: gpgui ref containing the update Worker and pinned WinSparkle tools
|
||||
required: true
|
||||
default: main
|
||||
type: string
|
||||
release_tag:
|
||||
description: GitHub release containing both tested native installers and signatures
|
||||
required: true
|
||||
type: string
|
||||
version:
|
||||
description: Base product version (x.y.z)
|
||||
required: true
|
||||
type: string
|
||||
channel:
|
||||
description: Update channel
|
||||
required: true
|
||||
type: choice
|
||||
options: [stable, snapshot]
|
||||
build:
|
||||
description: Numeric snapshot build; empty for stable
|
||||
type: string
|
||||
highlights:
|
||||
description: Release highlights, one per line
|
||||
required: true
|
||||
type: string
|
||||
|
||||
concurrency:
|
||||
group: update-feeds
|
||||
cancel-in-progress: false
|
||||
|
||||
jobs:
|
||||
publish:
|
||||
runs-on: windows-latest
|
||||
environment: macos-release
|
||||
permissions:
|
||||
contents: read
|
||||
env:
|
||||
REPOSITORY: yuezk/GlobalProtect-openconnect
|
||||
RELEASE_TAG: ${{ inputs.release_tag }}
|
||||
PRODUCT_VERSION: ${{ inputs.version }}
|
||||
UPDATE_CHANNEL: ${{ inputs.channel }}
|
||||
BUILD_VERSION: ${{ inputs.build }}
|
||||
UPDATE_HIGHLIGHTS: ${{ inputs.highlights }}
|
||||
WINDOWS_UPDATE_PUBLIC_KEY: ${{ vars.WINDOWS_UPDATE_PUBLIC_KEY }}
|
||||
WINDOWS_SIGNING_PUBLISHER: ${{ vars.WINDOWS_SIGNING_PUBLISHER }}
|
||||
UPDATES_WORKER_NAME: ${{ vars.UPDATES_WORKER_NAME || 'gp-updates' }}
|
||||
GH_TOKEN: ${{ github.token }}
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
- name: Checkout update Worker and build helpers
|
||||
uses: ./.github/actions/checkout-private
|
||||
with:
|
||||
token: ${{ secrets.GH_PAT }}
|
||||
ref: ${{ inputs.gpgui_ref }}
|
||||
path: gpgui
|
||||
- uses: actions/setup-python@v6
|
||||
with:
|
||||
python-version: '3.13'
|
||||
- uses: pnpm/action-setup@v5
|
||||
with:
|
||||
version: 9.15.1
|
||||
- uses: actions/setup-node@v6
|
||||
with:
|
||||
node-version: 22
|
||||
- name: Verify both tested native installers
|
||||
shell: pwsh
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
if ($env:PRODUCT_VERSION -notmatch '^\d+\.\d+\.\d+$') { throw 'Invalid product version.' }
|
||||
if ($env:UPDATE_CHANNEL -eq 'stable') {
|
||||
if ($env:RELEASE_TAG -ne "v$env:PRODUCT_VERSION" -or $env:BUILD_VERSION) { throw 'Stable release identity does not match.' }
|
||||
} elseif ($env:RELEASE_TAG -ne 'snapshot' -or $env:BUILD_VERSION -notmatch '^\d+(\.\d+){0,2}$') { throw 'Snapshot release identity does not match.' }
|
||||
$displayVersion = $env:PRODUCT_VERSION
|
||||
if ($env:UPDATE_CHANNEL -eq 'snapshot') { $displayVersion += "-snapshot.$env:BUILD_VERSION" }
|
||||
if (!$env:WINDOWS_UPDATE_PUBLIC_KEY) { throw 'Configure the Windows public update key before promotion.' }
|
||||
$downloads = Join-Path $env:RUNNER_TEMP 'windows-update'
|
||||
New-Item -ItemType Directory -Force $downloads | Out-Null
|
||||
. ./gpgui/scripts/windows-updates/Get-WinSparkle.ps1
|
||||
$tools = Get-WinSparkleTools (Join-Path $env:RUNNER_TEMP 'signing-tools')
|
||||
foreach ($architecture in @('x64','arm64')) {
|
||||
$name = "GPConnect_${displayVersion}_windows-$architecture-setup.exe"
|
||||
foreach ($asset in @($name, "$name.sig", "$name.sha256")) {
|
||||
gh release download $env:RELEASE_TAG --repo $env:REPOSITORY --pattern $asset --dir $downloads
|
||||
if ($LASTEXITCODE -ne 0) { throw "Missing release asset: $asset" }
|
||||
}
|
||||
$installer = Join-Path $downloads $name
|
||||
$sum = (Get-Content "$installer.sha256" -Raw).Trim()
|
||||
if ($sum -notmatch '^([a-fA-F0-9]{64}) (.+)$' -or $Matches[2] -ne $name) { throw 'Invalid installer checksum file.' }
|
||||
if ((Get-FileHash $installer).Hash -ne $Matches[1]) { throw 'Installer checksum mismatch.' }
|
||||
if ($env:WINDOWS_SIGNING_PUBLISHER) {
|
||||
$authenticode = Get-AuthenticodeSignature $installer
|
||||
if ($authenticode.Status -ne 'Valid' -or $authenticode.SignerCertificate.GetNameInfo([Security.Cryptography.X509Certificates.X509NameType]::SimpleName, $false) -ne $env:WINDOWS_SIGNING_PUBLISHER) { throw 'Installer publisher signature is invalid.' }
|
||||
}
|
||||
if ([Diagnostics.FileVersionInfo]::GetVersionInfo($installer).ProductVersion -ne $displayVersion) { throw 'Installer product version/build mismatch.' }
|
||||
$signature = (Get-Content "$installer.sig" -Raw).Trim()
|
||||
& $tools.Tool verify -p $env:WINDOWS_UPDATE_PUBLIC_KEY -s $signature $installer
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Installer update signature is invalid.' }
|
||||
}
|
||||
"WINDOWS_DISPLAY_VERSION=$displayVersion" >> $env:GITHUB_ENV
|
||||
- name: Preserve other feeds and generate Windows metadata
|
||||
shell: pwsh
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$public = 'gpgui/apps/update-feed-worker/public'
|
||||
python scripts/preserve-update-feeds.py --base-url https://updates.gpgui.com --directory $public
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Could not preserve published feeds.' }
|
||||
$notes = Join-Path $env:RUNNER_TEMP 'windows-highlights.txt'
|
||||
$env:UPDATE_HIGHLIGHTS | Set-Content $notes -Encoding utf8NoBOM
|
||||
$output = Join-Path $public 'windows'
|
||||
$previous = Join-Path $output 'latest.json'
|
||||
$arguments = @('scripts/windows-update-feed.py', '--version', $env:PRODUCT_VERSION,
|
||||
'--channel', $env:UPDATE_CHANNEL, '--released-at', [DateTime]::UtcNow.ToString('yyyy-MM-dd'),
|
||||
'--highlights-file', $notes, '--output', $output)
|
||||
foreach ($architecture in @('x64','arm64')) {
|
||||
$name = "GPConnect_$($env:WINDOWS_DISPLAY_VERSION)_windows-$architecture-setup.exe"
|
||||
$installer = Join-Path (Join-Path $env:RUNNER_TEMP 'windows-update') $name
|
||||
$arguments += @('--payload', $architecture, $installer,
|
||||
"https://github.com/$env:REPOSITORY/releases/download/$env:RELEASE_TAG/$name", "$installer.sig")
|
||||
}
|
||||
if (Test-Path $previous) { $arguments += @('--input', $previous) }
|
||||
if ($env:BUILD_VERSION) { $arguments += @('--build', $env:BUILD_VERSION) }
|
||||
python @arguments
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Invalid Windows metadata.' }
|
||||
- name: Deploy complete feed set
|
||||
shell: pwsh
|
||||
env:
|
||||
CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
|
||||
CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
pnpm --dir gpgui/apps/update-feed-worker install --frozen-lockfile --ignore-scripts
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Worker dependency installation failed.' }
|
||||
pnpm --dir gpgui/apps/update-feed-worker exec wrangler deploy --config wrangler.jsonc --name $env:UPDATES_WORKER_NAME
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Feed deployment failed.' }
|
||||
- name: Verify published Windows metadata
|
||||
shell: pwsh
|
||||
run: |
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$windows = 'gpgui/apps/update-feed-worker/public/windows'
|
||||
$feeds = @('latest.json', 'stable/appcast.xml', 'snapshot/appcast.xml') | Where-Object { Test-Path (Join-Path $windows $_) }
|
||||
foreach ($relative in $feeds) {
|
||||
$expected = [IO.File]::ReadAllBytes((Join-Path 'gpgui/apps/update-feed-worker/public/windows' $relative))
|
||||
$downloaded = Join-Path $env:RUNNER_TEMP ('published-' + ($relative -replace '/', '-'))
|
||||
$matched = $false
|
||||
foreach ($attempt in 1..10) {
|
||||
try {
|
||||
Invoke-WebRequest "https://updates.gpgui.com/windows/$relative" -UserAgent 'GPConnectReleasePublisher/1.0' -OutFile $downloaded
|
||||
$actual = [IO.File]::ReadAllBytes($downloaded)
|
||||
$matched = [Convert]::ToBase64String($expected) -eq [Convert]::ToBase64String($actual)
|
||||
} catch {
|
||||
Write-Host "Waiting for published feed: $relative ($attempt/10)"
|
||||
}
|
||||
if ($matched) { break }
|
||||
if ($attempt -lt 10) { Start-Sleep -Seconds 3 }
|
||||
}
|
||||
if (!$matched) { throw "Published feed does not match: $relative" }
|
||||
}
|
||||
Generated
+70
-1
@@ -297,6 +297,8 @@ dependencies = [
|
||||
"anyhow",
|
||||
"block2",
|
||||
"browser-launcher",
|
||||
"common",
|
||||
"dunce",
|
||||
"gpapi",
|
||||
"gtk",
|
||||
"html-escape",
|
||||
@@ -307,6 +309,7 @@ dependencies = [
|
||||
"objc2-security",
|
||||
"objc2-web-kit",
|
||||
"regex",
|
||||
"serde_json",
|
||||
"tauri",
|
||||
"tempfile",
|
||||
"tiny_http",
|
||||
@@ -316,6 +319,9 @@ dependencies = [
|
||||
"uuid",
|
||||
"uzers",
|
||||
"webkit2gtk",
|
||||
"webview2-com",
|
||||
"windows",
|
||||
"winreg 0.55.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -554,6 +560,7 @@ dependencies = [
|
||||
"open",
|
||||
"webbrowser",
|
||||
"which",
|
||||
"winreg 0.55.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1551,7 +1558,7 @@ dependencies = [
|
||||
"rustc_version",
|
||||
"toml 1.1.8+spec-1.1.0",
|
||||
"vswhom",
|
||||
"winreg",
|
||||
"winreg 0.56.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1655,6 +1662,16 @@ dependencies = [
|
||||
"rustc_version",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "file-rotate"
|
||||
version = "0.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e8e2fa049328a1f3295991407a88585805d126dfaadf74b9fe8c194c730aafc"
|
||||
dependencies = [
|
||||
"chrono",
|
||||
"flate2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "filedescriptor"
|
||||
version = "0.8.3"
|
||||
@@ -2169,6 +2186,7 @@ dependencies = [
|
||||
"uuid",
|
||||
"uzers",
|
||||
"whoami",
|
||||
"windows-sys 0.61.2",
|
||||
"x509-cert",
|
||||
"xmltree",
|
||||
"zeroize",
|
||||
@@ -2273,6 +2291,7 @@ dependencies = [
|
||||
"common",
|
||||
"compile-time",
|
||||
"env_logger",
|
||||
"file-rotate",
|
||||
"futures",
|
||||
"getrandom 0.4.3",
|
||||
"gpapi",
|
||||
@@ -2293,6 +2312,8 @@ dependencies = [
|
||||
"tokio-tungstenite 0.30.0",
|
||||
"tokio-util",
|
||||
"uuid",
|
||||
"windows-service",
|
||||
"windows-sys 0.61.2",
|
||||
"xz2",
|
||||
"zeroize",
|
||||
]
|
||||
@@ -2313,7 +2334,15 @@ dependencies = [
|
||||
name = "gpvpnc"
|
||||
version = "3.4.0"
|
||||
dependencies = [
|
||||
"base64 0.23.1",
|
||||
"ipnet",
|
||||
"log",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"tempfile",
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winreg 0.56.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -2815,6 +2844,9 @@ name = "ipnet"
|
||||
version = "2.12.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0"
|
||||
dependencies = [
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "is-docker"
|
||||
@@ -3835,6 +3867,7 @@ dependencies = [
|
||||
"log",
|
||||
"pkg-config",
|
||||
"tempfile",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -6730,6 +6763,12 @@ dependencies = [
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "widestring"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
|
||||
|
||||
[[package]]
|
||||
name = "winapi"
|
||||
version = "0.3.9"
|
||||
@@ -6880,6 +6919,17 @@ dependencies = [
|
||||
"windows-link",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-service"
|
||||
version = "0.8.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "857224b3b211c6f3616921f081ee54721ee3ad2ace2fac6a6337e032f7b4dcf2"
|
||||
dependencies = [
|
||||
"bitflags 2.13.2",
|
||||
"widestring",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-strings"
|
||||
version = "0.5.1"
|
||||
@@ -6907,6 +6957,15 @@ dependencies = [
|
||||
"windows-targets 0.52.6",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.59.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
|
||||
dependencies = [
|
||||
"windows-targets 0.52.6",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "windows-sys"
|
||||
version = "0.61.2"
|
||||
@@ -7073,6 +7132,16 @@ dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winreg"
|
||||
version = "0.55.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winreg"
|
||||
version = "0.56.0"
|
||||
|
||||
@@ -16,6 +16,9 @@ fn main() {
|
||||
resolve_commit(&repo_root, &source_commit)
|
||||
);
|
||||
|
||||
#[cfg(all(windows, feature = "webview-auth"))]
|
||||
println!("cargo:rerun-if-changed=icons/windows/icon.ico");
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
tauri_build::build()
|
||||
}
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 47 KiB |
@@ -1,8 +1,8 @@
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
use auth::forward_auth_callback;
|
||||
use auth::{BrowserAuthenticator, auth_prelogin};
|
||||
use clap::Parser;
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
use clap::Subcommand;
|
||||
#[cfg(feature = "webview-auth")]
|
||||
use gpapi::auth::AuthWindowTheme;
|
||||
@@ -49,7 +49,7 @@ See 'gpauth -h' for more information.
|
||||
"
|
||||
)]
|
||||
struct Cli {
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[command(subcommand)]
|
||||
command: Option<CliCommand>,
|
||||
|
||||
@@ -134,7 +134,7 @@ struct Cli {
|
||||
verbose: InfoLevelVerbosity,
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[derive(Subcommand)]
|
||||
enum CliCommand {
|
||||
#[command(hide = true)]
|
||||
@@ -272,7 +272,7 @@ fn init_logger(cli: &Cli) {
|
||||
pub async fn run() {
|
||||
let cli = Cli::parse();
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
if let Some(CliCommand::AuthCallback { callback }) = &cli.command {
|
||||
if let Err(err) = forward_auth_callback(callback).await {
|
||||
eprintln!("Failed to forward authentication callback: {err}");
|
||||
@@ -382,7 +382,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
fn callback_arguments_parse_separately() {
|
||||
let cli = Cli::try_parse_from([
|
||||
"gpauth",
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
{
|
||||
"bundle": {
|
||||
"icon": ["icons/windows/icon.ico"]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
#![cfg(windows)]
|
||||
|
||||
use auth::AuthCallbackReceiver;
|
||||
use std::{process::Stdio, time::Duration};
|
||||
|
||||
#[tokio::test]
|
||||
async fn callback_command_forwards_between_processes() {
|
||||
let receiver = AuthCallbackReceiver::bind().unwrap();
|
||||
let child = tokio::process::Command::new(env!("CARGO_BIN_EXE_gpauth"))
|
||||
.args([
|
||||
"auth-callback",
|
||||
"globalprotectcallback:cas-as=1&un=windows-fixture&token=callback-command-test",
|
||||
])
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true)
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let (data, output) = tokio::time::timeout(Duration::from_secs(10), async {
|
||||
tokio::join!(receiver.receive(), child.wait_with_output())
|
||||
})
|
||||
.await
|
||||
.expect("callback executable did not complete");
|
||||
let output = output.unwrap();
|
||||
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
|
||||
let data = data.unwrap();
|
||||
assert_eq!(data.username(), "windows-fixture");
|
||||
assert_eq!(data.token(), Some("callback-command-test"));
|
||||
}
|
||||
@@ -30,14 +30,24 @@ uuid = { workspace = true, features = ["v4"] }
|
||||
zeroize.workspace = true
|
||||
tempfile.workspace = true
|
||||
getrandom = "0.4"
|
||||
mac_address = "1.2.1"
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
nix = { version = "0.31", features = ["fs", "socket", "user"] }
|
||||
|
||||
[target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))'.dependencies]
|
||||
mac_address = "1.2.1"
|
||||
|
||||
[target.'cfg(unix)'.dev-dependencies]
|
||||
mac_address = "1.2.1"
|
||||
|
||||
[dev-dependencies]
|
||||
openssl.workspace = true
|
||||
tokio-tungstenite.workspace = true
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
[target.'cfg(any(target_os = "macos", windows))'.dependencies]
|
||||
gpvpnc = { path = "../../crates/gpvpnc" }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
file-rotate = "0.8.0"
|
||||
windows-service = "0.8.1"
|
||||
windows-sys = { version = "0.61", features = ["Win32_System_Pipes"] }
|
||||
@@ -6,7 +6,7 @@ use std::time::Duration;
|
||||
|
||||
use anyhow::{Context, bail};
|
||||
use clap::Parser;
|
||||
use common::constants::GP_SERVICE_LOCK_FILE;
|
||||
use common::paths::service_lock_file;
|
||||
use gpapi::clap::InfoLevelVerbosity;
|
||||
use gpapi::logger;
|
||||
#[cfg(debug_assertions)]
|
||||
@@ -25,14 +25,7 @@ use crate::{
|
||||
request_dispatcher::RequestDispatcher, session_registry::SessionRegistry, vpn_task::VpnTask, ws_server::WsServer,
|
||||
};
|
||||
|
||||
const VERSION: &str = concat!(
|
||||
env!("CARGO_PKG_VERSION"),
|
||||
" (",
|
||||
env!("GPSERVICE_GIT_COMMIT"),
|
||||
" ",
|
||||
compile_time::date_str!(),
|
||||
")"
|
||||
);
|
||||
use crate::VERSION;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
struct RedactingMacosLogger {
|
||||
@@ -271,7 +264,7 @@ impl Cli {
|
||||
return Ok(dev_service_lock_file_path(socket));
|
||||
}
|
||||
|
||||
Ok(PathBuf::from(GP_SERVICE_LOCK_FILE))
|
||||
Ok(service_lock_file())
|
||||
}
|
||||
|
||||
fn init_logger(&self) -> Arc<Redaction> {
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
use clap::Parser;
|
||||
use gpapi::clap::InfoLevelVerbosity;
|
||||
#[derive(Parser)]
|
||||
#[command(version = crate::VERSION)]
|
||||
struct Cli {
|
||||
#[command(flatten)]
|
||||
verbose: InfoLevelVerbosity,
|
||||
}
|
||||
pub fn run() -> anyhow::Result<()> {
|
||||
let cli = Cli::parse();
|
||||
crate::windows_service::dispatch(cli.verbose.log_level_filter().to_level().unwrap_or(log::Level::Info))
|
||||
}
|
||||
@@ -75,7 +75,7 @@ impl DesktopClient {
|
||||
loop {
|
||||
match self.read_control().await? {
|
||||
Some(DESKTOP_GUI_INSTALLER) => {
|
||||
self.write_all(&[u8::from(crate::request_dispatcher::gui_installer().is_some())]).await?;
|
||||
self.write_all(&[u8::from(crate::gui_installation::installer().is_some())]).await?;
|
||||
}
|
||||
Some(DESKTOP_SWITCH_BEGIN) => {
|
||||
ensure!(pending.is_none(), "A GUI switch is already pending");
|
||||
@@ -299,10 +299,7 @@ mod tests {
|
||||
let mut reader = reader;
|
||||
let mut capability = [0];
|
||||
reader.read_exact(&mut capability).unwrap();
|
||||
assert_eq!(
|
||||
capability[0],
|
||||
u8::from(crate::request_dispatcher::gui_installer().is_some())
|
||||
);
|
||||
assert_eq!(capability[0], u8::from(crate::gui_installation::installer().is_some()));
|
||||
reader
|
||||
})
|
||||
.await
|
||||
|
||||
@@ -366,7 +366,7 @@ mod tests {
|
||||
r#"{"version":1,"anchor":{"hardware_id":"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA","source":1}}"#
|
||||
);
|
||||
|
||||
for source in [0, 4] {
|
||||
for source in [0, u8::MAX] {
|
||||
let json = serde_json::json!({
|
||||
"version": 1,
|
||||
"anchor": {
|
||||
|
||||
@@ -0,0 +1,359 @@
|
||||
use gpapi::utils::checksum::verify_checksum;
|
||||
use std::{
|
||||
fs::{self, File, OpenOptions, Permissions},
|
||||
io::{BufReader, Read, Write},
|
||||
os::unix::fs::{OpenOptionsExt, PermissionsExt},
|
||||
path::Path,
|
||||
};
|
||||
use tar::Archive;
|
||||
use tempfile::NamedTempFile;
|
||||
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;
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum InstallError {
|
||||
Checksum(anyhow::Error),
|
||||
Install(anyhow::Error),
|
||||
}
|
||||
|
||||
pub(crate) fn installer() -> Option<std::path::PathBuf> {
|
||||
std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|executable| {
|
||||
executable
|
||||
.parent()?
|
||||
.parent()
|
||||
.map(|prefix| prefix.join("libexec/gpclient/gp-gui-installer"))
|
||||
})
|
||||
.filter(|path| path.is_file())
|
||||
}
|
||||
|
||||
pub(crate) fn install(src: &Path, checksum: &str, target: &Path) -> Result<(), InstallError> {
|
||||
let installer = installer();
|
||||
install_gui_with_installer(src, checksum, target, installer.as_deref())
|
||||
}
|
||||
|
||||
fn install_gui_with_installer(
|
||||
src: &Path,
|
||||
checksum: &str,
|
||||
target: &Path,
|
||||
installer: Option<&Path>,
|
||||
) -> Result<(), InstallError> {
|
||||
let Some(dir) = target.parent() else {
|
||||
return Err(InstallError::Install(anyhow::anyhow!(
|
||||
"Failed to get parent directory of GUI binary"
|
||||
)));
|
||||
};
|
||||
fs::create_dir_all(dir).map_err(|err| InstallError::Install(err.into()))?;
|
||||
|
||||
let staged_archive = stage_gui_archive(src, dir)?;
|
||||
let archive_path = staged_archive.path().to_string_lossy();
|
||||
verify_checksum(&archive_path, checksum).map_err(InstallError::Checksum)?;
|
||||
|
||||
// A package may need to prepare downloaded executables for its runtime.
|
||||
// Resolve this helper beside the running service, never from the request or PATH.
|
||||
if let Some(installer) = installer {
|
||||
let status = std::process::Command::new(installer)
|
||||
.arg(staged_archive.path())
|
||||
.arg(checksum)
|
||||
.arg(target)
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::null())
|
||||
.status()
|
||||
.map_err(|err| InstallError::Install(err.into()))?;
|
||||
return if status.success() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(InstallError::Install(anyhow::anyhow!(
|
||||
"GUI package installation failed: {status}"
|
||||
)))
|
||||
};
|
||||
}
|
||||
|
||||
let tar = XzDecoder::new(BufReader::new(
|
||||
staged_archive
|
||||
.reopen()
|
||||
.map_err(|err| InstallError::Install(err.into()))?,
|
||||
))
|
||||
.take(MAX_GUI_ARCHIVE_CONTENT_SIZE);
|
||||
let mut archive = Archive::new(tar);
|
||||
let binary_name = target.file_name().and_then(|name| name.to_str()).unwrap_or("gpgui");
|
||||
let file = extract_gui_binary(&mut archive, dir, binary_name)?;
|
||||
file
|
||||
.as_file()
|
||||
.set_permissions(Permissions::from_mode(0o755))
|
||||
.map_err(|err| InstallError::Install(err.into()))?;
|
||||
file
|
||||
.as_file()
|
||||
.sync_all()
|
||||
.map_err(|err| InstallError::Install(err.into()))?;
|
||||
file.persist(&target).map_err(|err| InstallError::Install(err.into()))?;
|
||||
File::open(dir)
|
||||
.and_then(|directory| directory.sync_all())
|
||||
.map_err(|err| InstallError::Install(err.into()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn stage_gui_archive(src: &Path, dir: &Path) -> Result<NamedTempFile, InstallError> {
|
||||
let mut source = OpenOptions::new()
|
||||
.read(true)
|
||||
.custom_flags(nix::libc::O_NONBLOCK | nix::libc::O_NOFOLLOW)
|
||||
.open(src)
|
||||
.map_err(|err| InstallError::Install(err.into()))?;
|
||||
let metadata = source.metadata().map_err(|err| InstallError::Install(err.into()))?;
|
||||
let source_size = metadata.len();
|
||||
if !metadata.file_type().is_file() || source_size == 0 || source_size > MAX_GUI_ARCHIVE_SIZE {
|
||||
return Err(InstallError::Install(anyhow::anyhow!(
|
||||
"GUI update archive must be a non-empty regular file no larger than {MAX_GUI_ARCHIVE_SIZE} bytes"
|
||||
)));
|
||||
}
|
||||
|
||||
let mut staged = NamedTempFile::new_in(dir).map_err(|err| InstallError::Install(err.into()))?;
|
||||
let copied = std::io::copy(&mut (&mut source).take(MAX_GUI_ARCHIVE_SIZE + 1), &mut staged)
|
||||
.map_err(|err| InstallError::Install(err.into()))?;
|
||||
if copied != source_size {
|
||||
return Err(InstallError::Install(anyhow::anyhow!(
|
||||
"GUI update archive changed while it was being read"
|
||||
)));
|
||||
}
|
||||
staged.flush().map_err(|err| InstallError::Install(err.into()))?;
|
||||
staged
|
||||
.as_file()
|
||||
.sync_all()
|
||||
.map_err(|err| InstallError::Install(err.into()))?;
|
||||
Ok(staged)
|
||||
}
|
||||
|
||||
fn extract_gui_binary<R: Read>(
|
||||
archive: &mut Archive<R>,
|
||||
dir: &Path,
|
||||
binary_name: &str,
|
||||
) -> Result<NamedTempFile, InstallError> {
|
||||
for entry in archive.entries().map_err(|err| InstallError::Install(err.into()))? {
|
||||
let mut entry = entry.map_err(|err| InstallError::Install(err.into()))?;
|
||||
let is_gui = entry
|
||||
.path()
|
||||
.map_err(|err| InstallError::Install(err.into()))?
|
||||
.file_name()
|
||||
.is_some_and(|name| name == binary_name);
|
||||
if is_gui && entry.header().entry_type().is_file() {
|
||||
let declared_size = entry.size();
|
||||
if declared_size == 0 || declared_size > MAX_GUI_BINARY_SIZE {
|
||||
return Err(InstallError::Install(anyhow::anyhow!(
|
||||
"GUI binary must be non-empty and no larger than {MAX_GUI_BINARY_SIZE} bytes"
|
||||
)));
|
||||
}
|
||||
let mut file = NamedTempFile::new_in(dir).map_err(|err| InstallError::Install(err.into()))?;
|
||||
let copied = std::io::copy(&mut entry, &mut file).map_err(|err| InstallError::Install(err.into()))?;
|
||||
if copied != declared_size {
|
||||
return Err(InstallError::Install(anyhow::anyhow!(
|
||||
"GUI binary size does not match its archive header"
|
||||
)));
|
||||
}
|
||||
file.flush().map_err(|err| InstallError::Install(err.into()))?;
|
||||
return Ok(file);
|
||||
}
|
||||
}
|
||||
Err(InstallError::Install(anyhow::anyhow!(
|
||||
"GUI update archive does not contain a non-empty regular {binary_name} file"
|
||||
)))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::{io::Cursor, os::unix::fs::PermissionsExt};
|
||||
|
||||
use tar::{Builder, EntryType, Header};
|
||||
use xz2::write::XzEncoder;
|
||||
|
||||
use super::*;
|
||||
|
||||
fn archive_with_entry(entry_type: EntryType, contents: &[u8]) -> Vec<u8> {
|
||||
let mut data = Vec::new();
|
||||
{
|
||||
let mut builder = Builder::new(&mut data);
|
||||
let mut header = Header::new_gnu();
|
||||
header.set_entry_type(entry_type);
|
||||
header.set_size(contents.len() as u64);
|
||||
header.set_mode(0o755);
|
||||
header.set_cksum();
|
||||
builder.append_data(&mut header, "gpgui", contents).unwrap();
|
||||
builder.finish().unwrap();
|
||||
}
|
||||
data
|
||||
}
|
||||
|
||||
fn compressed_gui_archive(contents: &[u8]) -> NamedTempFile {
|
||||
let tar = archive_with_entry(EntryType::Regular, contents);
|
||||
let mut encoder = XzEncoder::new(Vec::new(), 6);
|
||||
encoder.write_all(&tar).unwrap();
|
||||
let compressed = encoder.finish().unwrap();
|
||||
let mut archive = NamedTempFile::new().unwrap();
|
||||
archive.write_all(&compressed).unwrap();
|
||||
archive.flush().unwrap();
|
||||
archive
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_non_file_and_empty_gui_entries() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
for (entry_type, contents) in [(EntryType::Directory, &[][..]), (EntryType::Regular, &[][..])] {
|
||||
let data = archive_with_entry(entry_type, contents);
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extracts_non_empty_regular_gui_entry() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let data = archive_with_entry(EntryType::Regular, b"gui binary");
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
let extracted = extract_gui_binary(&mut archive, output.path(), "gpgui").unwrap();
|
||||
let contents = std::fs::read(extracted.path()).unwrap();
|
||||
assert_eq!(contents, b"gui binary");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_invalid_archive_sources() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
assert!(stage_gui_archive(output.path(), output.path()).is_err());
|
||||
|
||||
let oversized = output.path().join("oversized.tar.xz");
|
||||
File::create(&oversized)
|
||||
.unwrap()
|
||||
.set_len(MAX_GUI_ARCHIVE_SIZE + 1)
|
||||
.unwrap();
|
||||
assert!(stage_gui_archive(&oversized, output.path()).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_oversized_gui_entry() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let mut header = Header::new_gnu();
|
||||
header.set_entry_type(EntryType::Regular);
|
||||
header.set_size(MAX_GUI_BINARY_SIZE + 1);
|
||||
header.set_mode(0o755);
|
||||
header.set_path("gpgui").unwrap();
|
||||
header.set_cksum();
|
||||
let mut data = header.as_bytes().to_vec();
|
||||
data.resize(512 * 3, 0);
|
||||
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn installs_gui_at_the_supplied_target() {
|
||||
let archive = compressed_gui_archive(b"gui binary");
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpclient/gpgui");
|
||||
|
||||
install(archive.path(), &checksum, &target).unwrap();
|
||||
|
||||
assert_eq!(std::fs::read(&target).unwrap(), b"gui binary");
|
||||
assert_eq!(std::fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o755);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn installs_nsh_beside_tauri_without_replacing_it() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let tauri = output.path().join("gpgui");
|
||||
std::fs::write(&tauri, b"tauri").unwrap();
|
||||
let mut encoder = XzEncoder::new(Vec::new(), 1);
|
||||
{
|
||||
let mut archive = Builder::new(&mut encoder);
|
||||
let mut header = Header::new_gnu();
|
||||
header.set_size(3);
|
||||
header.set_mode(0o755);
|
||||
header.set_cksum();
|
||||
archive
|
||||
.append_data(&mut header, "gpgui-nsh_3.2.0/gpgui-nsh", &b"nsh"[..])
|
||||
.unwrap();
|
||||
archive.finish().unwrap();
|
||||
}
|
||||
let mut archive = NamedTempFile::new().unwrap();
|
||||
archive.write_all(&encoder.finish().unwrap()).unwrap();
|
||||
archive.flush().unwrap();
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let nsh = output.path().join("gpgui-nsh");
|
||||
install(archive.path(), &checksum, &nsh).unwrap();
|
||||
assert_eq!(std::fs::read(nsh).unwrap(), b"nsh");
|
||||
assert_eq!(std::fs::read(tauri).unwrap(), b"tauri");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn checksum_failure_preserves_the_existing_gui() {
|
||||
let archive = compressed_gui_archive(b"replacement");
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpclient/gpgui");
|
||||
std::fs::create_dir_all(target.parent().unwrap()).unwrap();
|
||||
std::fs::write(&target, b"existing").unwrap();
|
||||
|
||||
assert!(install(archive.path(), "invalid", &target).is_err());
|
||||
assert_eq!(std::fs::read(target).unwrap(), b"existing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn package_installer_receives_a_verified_staged_archive() {
|
||||
let archive = compressed_gui_archive(b"gui binary");
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpgui-nsh");
|
||||
let installer = output.path().join("installer");
|
||||
std::fs::write(
|
||||
&installer,
|
||||
"#!/bin/sh\nset -eu\ntest -f \"$1\"\nprintf '%s' \"$2\" > \"$3\"\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
|
||||
|
||||
assert!(install_gui_with_installer(archive.path(), "invalid", &target, Some(&installer)).is_err());
|
||||
assert!(!target.exists());
|
||||
install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).unwrap();
|
||||
assert_eq!(std::fs::read_to_string(target).unwrap(), checksum);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn package_installation_failure_preserves_the_existing_gui() {
|
||||
let archive = compressed_gui_archive(b"replacement");
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpgui");
|
||||
std::fs::write(&target, b"existing").unwrap();
|
||||
let installer = output.path().join("installer");
|
||||
std::fs::write(&installer, "#!/bin/sh\nexit 1\n").unwrap();
|
||||
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
|
||||
|
||||
assert!(install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).is_err());
|
||||
assert_eq!(std::fs::read(target).unwrap(), b"existing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires GP_TEST_GUI_BINARY pointing to a built gpgui"]
|
||||
fn installs_single_gui_binary_for_fresh_and_upgrade_downloads() {
|
||||
let binary = std::fs::read(std::env::var("GP_TEST_GUI_BINARY").expect("GP_TEST_GUI_BINARY")).unwrap();
|
||||
let archive = compressed_gui_archive(&binary);
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let output = std::env::var_os("GP_TEST_GUI_INSTALL_DIR")
|
||||
.map(std::path::PathBuf::from)
|
||||
.unwrap_or_else(|| temporary.path().to_owned());
|
||||
std::fs::create_dir_all(&output).unwrap();
|
||||
std::fs::set_permissions(&output, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let target = output.join("gpclient/gpgui");
|
||||
for upgrade in [false, true] {
|
||||
if upgrade {
|
||||
std::fs::write(&target, b"old GUI").unwrap();
|
||||
}
|
||||
install(archive.path(), &checksum, &target).unwrap();
|
||||
assert_eq!(std::fs::read_dir(target.parent().unwrap()).unwrap().count(), 1);
|
||||
assert_eq!(std::fs::read(&target).unwrap(), binary);
|
||||
let result = std::process::Command::new(&target).arg("--version").output().unwrap();
|
||||
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
|
||||
assert!(String::from_utf8_lossy(&result.stdout).contains(env!("CARGO_PKG_VERSION")));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
use std::{fs, io, os::unix::fs::PermissionsExt, path::PathBuf, sync::Arc};
|
||||
use std::{io, sync::Arc};
|
||||
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::{
|
||||
@@ -6,7 +6,17 @@ use gpapi::{
|
||||
os_profile::{ClientOs, HostIdentity, OsProfile, OsProfileBuilder},
|
||||
};
|
||||
use gphip::{ReportContext, ReportInput};
|
||||
use openconnect::{HipRequest, HipScript, HipScriptEnvironment};
|
||||
use openconnect::HipRequest;
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
use openconnect::HipScript;
|
||||
#[cfg(unix)]
|
||||
#[path = "hip_source/unix.rs"]
|
||||
mod scripts;
|
||||
#[cfg(windows)]
|
||||
#[path = "hip_source/windows.rs"]
|
||||
mod scripts;
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
use scripts::script_environment;
|
||||
|
||||
pub(crate) struct HipExecution {
|
||||
pub source: openconnect::HipSource,
|
||||
@@ -36,7 +46,7 @@ impl HipApproval {
|
||||
pub(crate) fn resolve(
|
||||
source: &HipSource,
|
||||
desktop_uid: Option<u32>,
|
||||
brokered_macos: bool,
|
||||
restricted_desktop: bool,
|
||||
edited_report: Option<Arc<str>>,
|
||||
profile: Option<OsProfile>,
|
||||
) -> anyhow::Result<HipExecution> {
|
||||
@@ -63,22 +73,11 @@ pub(crate) fn resolve(
|
||||
}
|
||||
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)
|
||||
ensure_custom_available(restricted_desktop)?;
|
||||
scripts::user_script(path, desktop_uid)?
|
||||
}
|
||||
HipSource::ApprovedRootScript { approval_id } => {
|
||||
ensure_custom_available(brokered_macos)?;
|
||||
ensure_custom_available(restricted_desktop)?;
|
||||
#[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")?;
|
||||
@@ -113,10 +112,10 @@ pub(crate) fn resolve(
|
||||
})
|
||||
}
|
||||
|
||||
fn ensure_custom_available(brokered_macos: bool) -> anyhow::Result<()> {
|
||||
fn ensure_custom_available(restricted_desktop: bool) -> anyhow::Result<()> {
|
||||
ensure!(
|
||||
!cfg!(target_os = "macos") && !brokered_macos,
|
||||
"Custom HIP scripts are unavailable on macOS"
|
||||
!cfg!(target_os = "macos") && !restricted_desktop,
|
||||
"Custom HIP scripts are unavailable on this platform"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
@@ -149,27 +148,6 @@ pub(crate) fn generate(
|
||||
}
|
||||
}
|
||||
|
||||
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,
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
use anyhow::{Context, ensure};
|
||||
use openconnect::{HipScript, HipScriptEnvironment};
|
||||
use std::{fs, os::unix::fs::PermissionsExt, path::PathBuf};
|
||||
pub(super) fn user_script(path: &str, desktop_uid: Option<u32>) -> anyhow::Result<openconnect::HipSource> {
|
||||
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)?)?;
|
||||
Ok(openconnect::HipSource::Script(script))
|
||||
}
|
||||
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,
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
pub(super) fn user_script(_path: &str, _desktop_uid: Option<u32>) -> anyhow::Result<openconnect::HipSource> {
|
||||
anyhow::bail!("Custom HIP scripts are unavailable on Windows")
|
||||
}
|
||||
@@ -1,11 +1,15 @@
|
||||
#[cfg_attr(windows, path = "cli/windows.rs")]
|
||||
mod cli;
|
||||
#[cfg(all(unix, any(target_os = "macos", debug_assertions)))]
|
||||
mod credential_lease;
|
||||
#[cfg(unix)]
|
||||
mod desktop_client;
|
||||
#[cfg(debug_assertions)]
|
||||
#[cfg(all(debug_assertions, unix))]
|
||||
mod dev_bootstrap;
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", all(test, unix)))]
|
||||
mod device_anchor;
|
||||
#[cfg(unix)]
|
||||
mod gui_installation;
|
||||
mod handlers;
|
||||
mod hip_preview;
|
||||
mod hip_source;
|
||||
@@ -13,6 +17,7 @@ mod hip_source;
|
||||
mod macos_broker;
|
||||
mod request_dispatcher;
|
||||
mod routes;
|
||||
#[cfg(unix)]
|
||||
mod runtime_user;
|
||||
mod session_registry;
|
||||
mod vpn_script;
|
||||
@@ -20,7 +25,31 @@ mod vpn_task;
|
||||
mod ws_connection;
|
||||
mod ws_server;
|
||||
|
||||
#[cfg(windows)]
|
||||
mod windows_service;
|
||||
|
||||
const VERSION: &str = concat!(
|
||||
env!("CARGO_PKG_VERSION"),
|
||||
" (",
|
||||
env!("GPSERVICE_GIT_COMMIT"),
|
||||
" ",
|
||||
compile_time::date_str!(),
|
||||
")"
|
||||
);
|
||||
|
||||
#[cfg(unix)]
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
cli::run().await;
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn main() -> std::process::ExitCode {
|
||||
match cli::run() {
|
||||
Ok(()) => std::process::ExitCode::SUCCESS,
|
||||
Err(error) => {
|
||||
eprintln!("{error:#}");
|
||||
std::process::ExitCode::FAILURE
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,27 +1,15 @@
|
||||
use std::{
|
||||
fs::{self, File, OpenOptions, Permissions},
|
||||
io::{BufReader, Read, Write},
|
||||
os::unix::fs::{OpenOptionsExt, PermissionsExt},
|
||||
path::Path,
|
||||
sync::{Arc, atomic::AtomicBool},
|
||||
};
|
||||
use std::sync::{Arc, atomic::AtomicBool};
|
||||
|
||||
use gpapi::{
|
||||
service::{
|
||||
request::{UpdateGuiRequest, UpdateLogLevelRequest, WsRequest},
|
||||
transport::{ServiceErrorCode, ServiceResult},
|
||||
},
|
||||
utils::{checksum::verify_checksum, redact::Redaction},
|
||||
utils::redact::Redaction,
|
||||
};
|
||||
use log::{info, warn};
|
||||
use tar::Archive;
|
||||
use tempfile::NamedTempFile;
|
||||
#[cfg(unix)]
|
||||
use tokio::sync::Mutex;
|
||||
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>,
|
||||
@@ -75,9 +63,10 @@ pub struct RequestDispatcher {
|
||||
lifecycle: crate::vpn_task::LifecycleHandle,
|
||||
gui_restart_requested: Arc<AtomicBool>,
|
||||
redaction: Arc<Redaction>,
|
||||
#[cfg(unix)]
|
||||
install_lock: Mutex<()>,
|
||||
gui_management_enabled: bool,
|
||||
externally_brokered: bool,
|
||||
restricted_desktop: bool,
|
||||
}
|
||||
|
||||
impl RequestDispatcher {
|
||||
@@ -89,15 +78,16 @@ impl RequestDispatcher {
|
||||
gui_restart_requested: Arc<AtomicBool>,
|
||||
redaction: Arc<Redaction>,
|
||||
gui_management_enabled: bool,
|
||||
externally_brokered: bool,
|
||||
restricted_desktop: bool,
|
||||
) -> Self {
|
||||
Self {
|
||||
lifecycle,
|
||||
gui_restart_requested,
|
||||
redaction,
|
||||
#[cfg(unix)]
|
||||
install_lock: Mutex::new(()),
|
||||
gui_management_enabled,
|
||||
externally_brokered,
|
||||
restricted_desktop,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -202,7 +192,7 @@ impl RequestDispatcher {
|
||||
edited_report,
|
||||
} => {
|
||||
let prepared =
|
||||
crate::vpn_task::prepare_connection(*request, self.externally_brokered, preparation.cancellation()).await;
|
||||
crate::vpn_task::prepare_connection(*request, self.restricted_desktop, preparation.cancellation()).await;
|
||||
return match prepared {
|
||||
Ok(connection) => preparation.commit(connection, desktop_uid, edited_report),
|
||||
Err(error) => {
|
||||
@@ -279,24 +269,25 @@ impl RequestDispatcher {
|
||||
}
|
||||
|
||||
fn validate_connect_request(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
|
||||
if !self.externally_brokered {
|
||||
if !self.restricted_desktop {
|
||||
return Ok(());
|
||||
}
|
||||
if request.args().vpnc_script().is_some() {
|
||||
return Err("macOS does not support custom VPN scripts");
|
||||
return Err("Custom VPN scripts are unavailable on this platform");
|
||||
}
|
||||
if matches!(
|
||||
request.args().hip_source(),
|
||||
gpapi::hip::HipSource::UserScript { .. } | gpapi::hip::HipSource::ApprovedRootScript { .. }
|
||||
) {
|
||||
return Err("macOS does not support custom HIP scripts");
|
||||
return Err("Custom HIP scripts are unavailable on this platform");
|
||||
}
|
||||
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");
|
||||
return Err("Client identity must be provided as certificate data");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
async fn update_gui(&self, request: UpdateGuiRequest) -> ServiceResult {
|
||||
if request.variant == gpapi::gui::GuiVariant::Nsh && !cfg!(target_os = "linux") {
|
||||
return ServiceResult::rejected(
|
||||
@@ -308,14 +299,17 @@ impl RequestDispatcher {
|
||||
let path = request.path;
|
||||
let checksum = request.checksum;
|
||||
let target = request.variant.update_target();
|
||||
let installed = tokio::task::spawn_blocking(move || install_gui_at(Path::new(&path), &checksum, &target)).await;
|
||||
let installed = tokio::task::spawn_blocking(move || {
|
||||
crate::gui_installation::install(std::path::Path::new(&path), &checksum, &target)
|
||||
})
|
||||
.await;
|
||||
match installed {
|
||||
Ok(Ok(())) => ServiceResult::Accepted,
|
||||
Ok(Err(GuiInstallError::Checksum(err))) => {
|
||||
Ok(Err(crate::gui_installation::InstallError::Checksum(err))) => {
|
||||
warn!("Failed to verify GUI update checksum: {err}");
|
||||
ServiceResult::rejected(ServiceErrorCode::ChecksumFailed, "GUI update checksum failed")
|
||||
}
|
||||
Ok(Err(GuiInstallError::Install(err))) => {
|
||||
Ok(Err(crate::gui_installation::InstallError::Install(err))) => {
|
||||
warn!("Failed to install GUI update: {err}");
|
||||
ServiceResult::rejected(ServiceErrorCode::InstallFailed, "GUI update installation failed")
|
||||
}
|
||||
@@ -325,335 +319,20 @@ impl RequestDispatcher {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum GuiInstallError {
|
||||
Checksum(anyhow::Error),
|
||||
Install(anyhow::Error),
|
||||
}
|
||||
|
||||
pub(crate) fn gui_installer() -> Option<std::path::PathBuf> {
|
||||
std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|executable| {
|
||||
executable
|
||||
.parent()?
|
||||
.parent()
|
||||
.map(|prefix| prefix.join("libexec/gpclient/gp-gui-installer"))
|
||||
})
|
||||
.filter(|path| path.is_file())
|
||||
}
|
||||
|
||||
fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiInstallError> {
|
||||
let installer = gui_installer();
|
||||
install_gui_with_installer(src, checksum, target, installer.as_deref())
|
||||
}
|
||||
|
||||
fn install_gui_with_installer(
|
||||
src: &Path,
|
||||
checksum: &str,
|
||||
target: &Path,
|
||||
installer: Option<&Path>,
|
||||
) -> Result<(), GuiInstallError> {
|
||||
let Some(dir) = target.parent() else {
|
||||
return Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"Failed to get parent directory of GUI binary"
|
||||
)));
|
||||
};
|
||||
fs::create_dir_all(dir).map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
|
||||
let staged_archive = stage_gui_archive(src, dir)?;
|
||||
let archive_path = staged_archive.path().to_string_lossy();
|
||||
verify_checksum(&archive_path, checksum).map_err(GuiInstallError::Checksum)?;
|
||||
|
||||
// A package may need to prepare downloaded executables for its runtime.
|
||||
// Resolve this helper beside the running service, never from the request or PATH.
|
||||
if let Some(installer) = installer {
|
||||
let status = std::process::Command::new(installer)
|
||||
.arg(staged_archive.path())
|
||||
.arg(checksum)
|
||||
.arg(target)
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::null())
|
||||
.status()
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
return if status.success() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"GUI package installation failed: {status}"
|
||||
)))
|
||||
};
|
||||
#[cfg(windows)]
|
||||
async fn update_gui(&self, _request: UpdateGuiRequest) -> ServiceResult {
|
||||
ServiceResult::rejected(
|
||||
ServiceErrorCode::InvalidRequest,
|
||||
"Use the Windows installer to update GP Connect",
|
||||
)
|
||||
}
|
||||
|
||||
let tar = XzDecoder::new(BufReader::new(
|
||||
staged_archive
|
||||
.reopen()
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?,
|
||||
))
|
||||
.take(MAX_GUI_ARCHIVE_CONTENT_SIZE);
|
||||
let mut archive = Archive::new(tar);
|
||||
let binary_name = target.file_name().and_then(|name| name.to_str()).unwrap_or("gpgui");
|
||||
let file = extract_gui_binary(&mut archive, dir, binary_name)?;
|
||||
file
|
||||
.as_file()
|
||||
.set_permissions(Permissions::from_mode(0o755))
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
file
|
||||
.as_file()
|
||||
.sync_all()
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
file
|
||||
.persist(&target)
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
File::open(dir)
|
||||
.and_then(|directory| directory.sync_all())
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn stage_gui_archive(src: &Path, dir: &Path) -> Result<NamedTempFile, GuiInstallError> {
|
||||
let mut source = OpenOptions::new()
|
||||
.read(true)
|
||||
.custom_flags(nix::libc::O_NONBLOCK | nix::libc::O_NOFOLLOW)
|
||||
.open(src)
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
let metadata = source.metadata().map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
let source_size = metadata.len();
|
||||
if !metadata.file_type().is_file() || source_size == 0 || source_size > MAX_GUI_ARCHIVE_SIZE {
|
||||
return Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"GUI update archive must be a non-empty regular file no larger than {MAX_GUI_ARCHIVE_SIZE} bytes"
|
||||
)));
|
||||
}
|
||||
|
||||
let mut staged = NamedTempFile::new_in(dir).map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
let copied = std::io::copy(&mut (&mut source).take(MAX_GUI_ARCHIVE_SIZE + 1), &mut staged)
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
if copied != source_size {
|
||||
return Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"GUI update archive changed while it was being read"
|
||||
)));
|
||||
}
|
||||
staged.flush().map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
staged
|
||||
.as_file()
|
||||
.sync_all()
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
Ok(staged)
|
||||
}
|
||||
|
||||
fn extract_gui_binary<R: Read>(
|
||||
archive: &mut Archive<R>,
|
||||
dir: &Path,
|
||||
binary_name: &str,
|
||||
) -> Result<NamedTempFile, GuiInstallError> {
|
||||
for entry in archive.entries().map_err(|err| GuiInstallError::Install(err.into()))? {
|
||||
let mut entry = entry.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
let is_gui = entry
|
||||
.path()
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?
|
||||
.file_name()
|
||||
.is_some_and(|name| name == binary_name);
|
||||
if is_gui && entry.header().entry_type().is_file() {
|
||||
let declared_size = entry.size();
|
||||
if declared_size == 0 || declared_size > MAX_GUI_BINARY_SIZE {
|
||||
return Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"GUI binary must be non-empty and no larger than {MAX_GUI_BINARY_SIZE} bytes"
|
||||
)));
|
||||
}
|
||||
let mut file = NamedTempFile::new_in(dir).map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
let copied = std::io::copy(&mut entry, &mut file).map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
if copied != declared_size {
|
||||
return Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"GUI binary size does not match its archive header"
|
||||
)));
|
||||
}
|
||||
file.flush().map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
return Ok(file);
|
||||
}
|
||||
}
|
||||
Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"GUI update archive does not contain a non-empty regular {binary_name} file"
|
||||
)))
|
||||
}
|
||||
|
||||
#[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},
|
||||
};
|
||||
use tar::{Builder, EntryType, Header};
|
||||
use xz2::write::XzEncoder;
|
||||
|
||||
use super::*;
|
||||
|
||||
fn archive_with_entry(entry_type: EntryType, contents: &[u8]) -> Vec<u8> {
|
||||
let mut data = Vec::new();
|
||||
{
|
||||
let mut builder = Builder::new(&mut data);
|
||||
let mut header = Header::new_gnu();
|
||||
header.set_entry_type(entry_type);
|
||||
header.set_size(contents.len() as u64);
|
||||
header.set_mode(0o755);
|
||||
header.set_cksum();
|
||||
builder.append_data(&mut header, "gpgui", contents).unwrap();
|
||||
builder.finish().unwrap();
|
||||
}
|
||||
data
|
||||
}
|
||||
|
||||
fn compressed_gui_archive(contents: &[u8]) -> NamedTempFile {
|
||||
let tar = archive_with_entry(EntryType::Regular, contents);
|
||||
let mut encoder = XzEncoder::new(Vec::new(), 6);
|
||||
encoder.write_all(&tar).unwrap();
|
||||
let compressed = encoder.finish().unwrap();
|
||||
let mut archive = NamedTempFile::new().unwrap();
|
||||
archive.write_all(&compressed).unwrap();
|
||||
archive.flush().unwrap();
|
||||
archive
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_non_file_and_empty_gui_entries() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
for (entry_type, contents) in [(EntryType::Directory, &[][..]), (EntryType::Regular, &[][..])] {
|
||||
let data = archive_with_entry(entry_type, contents);
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extracts_non_empty_regular_gui_entry() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let data = archive_with_entry(EntryType::Regular, b"gui binary");
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
let extracted = extract_gui_binary(&mut archive, output.path(), "gpgui").unwrap();
|
||||
let contents = std::fs::read(extracted.path()).unwrap();
|
||||
assert_eq!(contents, b"gui binary");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_invalid_archive_sources() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
assert!(stage_gui_archive(output.path(), output.path()).is_err());
|
||||
|
||||
let oversized = output.path().join("oversized.tar.xz");
|
||||
File::create(&oversized)
|
||||
.unwrap()
|
||||
.set_len(MAX_GUI_ARCHIVE_SIZE + 1)
|
||||
.unwrap();
|
||||
assert!(stage_gui_archive(&oversized, output.path()).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_oversized_gui_entry() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let mut header = Header::new_gnu();
|
||||
header.set_entry_type(EntryType::Regular);
|
||||
header.set_size(MAX_GUI_BINARY_SIZE + 1);
|
||||
header.set_mode(0o755);
|
||||
header.set_path("gpgui").unwrap();
|
||||
header.set_cksum();
|
||||
let mut data = header.as_bytes().to_vec();
|
||||
data.resize(512 * 3, 0);
|
||||
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn installs_gui_at_the_supplied_target() {
|
||||
let archive = compressed_gui_archive(b"gui binary");
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpclient/gpgui");
|
||||
|
||||
install_gui_at(archive.path(), &checksum, &target).unwrap();
|
||||
|
||||
assert_eq!(std::fs::read(&target).unwrap(), b"gui binary");
|
||||
assert_eq!(std::fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o755);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn installs_nsh_beside_tauri_without_replacing_it() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let tauri = output.path().join("gpgui");
|
||||
std::fs::write(&tauri, b"tauri").unwrap();
|
||||
let mut encoder = XzEncoder::new(Vec::new(), 1);
|
||||
{
|
||||
let mut archive = Builder::new(&mut encoder);
|
||||
let mut header = Header::new_gnu();
|
||||
header.set_size(3);
|
||||
header.set_mode(0o755);
|
||||
header.set_cksum();
|
||||
archive
|
||||
.append_data(&mut header, "gpgui-nsh_3.2.0/gpgui-nsh", &b"nsh"[..])
|
||||
.unwrap();
|
||||
archive.finish().unwrap();
|
||||
}
|
||||
let mut archive = NamedTempFile::new().unwrap();
|
||||
archive.write_all(&encoder.finish().unwrap()).unwrap();
|
||||
archive.flush().unwrap();
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let nsh = output.path().join("gpgui-nsh");
|
||||
install_gui_at(archive.path(), &checksum, &nsh).unwrap();
|
||||
assert_eq!(std::fs::read(nsh).unwrap(), b"nsh");
|
||||
assert_eq!(std::fs::read(tauri).unwrap(), b"tauri");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn checksum_failure_preserves_the_existing_gui() {
|
||||
let archive = compressed_gui_archive(b"replacement");
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpclient/gpgui");
|
||||
std::fs::create_dir_all(target.parent().unwrap()).unwrap();
|
||||
std::fs::write(&target, b"existing").unwrap();
|
||||
|
||||
assert!(install_gui_at(archive.path(), "invalid", &target).is_err());
|
||||
assert_eq!(std::fs::read(target).unwrap(), b"existing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn package_installer_receives_a_verified_staged_archive() {
|
||||
let archive = compressed_gui_archive(b"gui binary");
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpgui-nsh");
|
||||
let installer = output.path().join("installer");
|
||||
std::fs::write(
|
||||
&installer,
|
||||
"#!/bin/sh\nset -eu\ntest -f \"$1\"\nprintf '%s' \"$2\" > \"$3\"\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
|
||||
|
||||
assert!(install_gui_with_installer(archive.path(), "invalid", &target, Some(&installer)).is_err());
|
||||
assert!(!target.exists());
|
||||
install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).unwrap();
|
||||
assert_eq!(std::fs::read_to_string(target).unwrap(), checksum);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn package_installation_failure_preserves_the_existing_gui() {
|
||||
let archive = compressed_gui_archive(b"replacement");
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let target = output.path().join("gpgui");
|
||||
std::fs::write(&target, b"existing").unwrap();
|
||||
let installer = output.path().join("installer");
|
||||
std::fs::write(&installer, "#!/bin/sh\nexit 1\n").unwrap();
|
||||
std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap();
|
||||
|
||||
assert!(install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).is_err());
|
||||
assert_eq!(std::fs::read(target).unwrap(), b"existing");
|
||||
}
|
||||
|
||||
use crate::vpn_task::test_connect_request as test_request;
|
||||
use gpapi::gateway::Gateway;
|
||||
#[tokio::test]
|
||||
async fn brokered_mode_rejects_gui_management_and_root_readable_identity_paths() {
|
||||
let dispatcher = RequestDispatcher::new(
|
||||
@@ -700,7 +379,7 @@ mod tests {
|
||||
let custom = test_request(info.clone()).with_vpnc_script(Some(script.to_string()));
|
||||
assert_eq!(
|
||||
dispatcher.validate_connect_request(&custom),
|
||||
Err("macOS does not support custom VPN scripts")
|
||||
Err("Custom VPN scripts are unavailable on this platform")
|
||||
);
|
||||
}
|
||||
|
||||
@@ -709,32 +388,7 @@ mod tests {
|
||||
});
|
||||
assert_eq!(
|
||||
dispatcher.validate_connect_request(&custom),
|
||||
Err("macOS does not support custom HIP scripts")
|
||||
Err("Custom HIP scripts are unavailable on this platform")
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
#[ignore = "requires GP_TEST_GUI_BINARY pointing to a built gpgui"]
|
||||
fn installs_single_gui_binary_for_fresh_and_upgrade_downloads() {
|
||||
let binary = std::fs::read(std::env::var("GP_TEST_GUI_BINARY").expect("GP_TEST_GUI_BINARY")).unwrap();
|
||||
let archive = compressed_gui_archive(&binary);
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let output = std::env::var_os("GP_TEST_GUI_INSTALL_DIR")
|
||||
.map(std::path::PathBuf::from)
|
||||
.unwrap_or_else(|| temporary.path().to_owned());
|
||||
std::fs::create_dir_all(&output).unwrap();
|
||||
std::fs::set_permissions(&output, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let target = output.join("gpclient/gpgui");
|
||||
for upgrade in [false, true] {
|
||||
if upgrade {
|
||||
std::fs::write(&target, b"old GUI").unwrap();
|
||||
}
|
||||
install_gui_at(archive.path(), &checksum, &target).unwrap();
|
||||
assert_eq!(std::fs::read_dir(target.parent().unwrap()).unwrap().count(), 1);
|
||||
assert_eq!(std::fs::read(&target).unwrap(), binary);
|
||||
let result = std::process::Command::new(&target).arg("--version").output().unwrap();
|
||||
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
|
||||
assert!(String::from_utf8_lossy(&result.stdout).contains(env!("CARGO_PKG_VERSION")));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -62,6 +62,8 @@ enum SessionStatus {
|
||||
}
|
||||
|
||||
struct SessionRecord {
|
||||
#[cfg(windows)]
|
||||
windows_identity: Option<Arc<gpapi::windows::PipeClientIdentity>>,
|
||||
non_tunnel: Option<AttachmentAttempt>,
|
||||
closed_attachment: Option<Uuid>,
|
||||
secret: Zeroizing<[u8; 32]>,
|
||||
@@ -255,6 +257,8 @@ impl SessionRegistry {
|
||||
sessions.insert(
|
||||
credential.session_id(),
|
||||
SessionRecord {
|
||||
#[cfg(windows)]
|
||||
windows_identity: None,
|
||||
non_tunnel: None,
|
||||
closed_attachment: None,
|
||||
secret: Zeroizing::new(*credential.secret()),
|
||||
@@ -273,6 +277,38 @@ impl SessionRegistry {
|
||||
Ok(credential)
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
pub(crate) fn issue_windows(
|
||||
&self,
|
||||
product_version: &str,
|
||||
identity: Arc<gpapi::windows::PipeClientIdentity>,
|
||||
) -> Result<Arc<SessionCredential>, SessionError> {
|
||||
let credential = self.issue(product_version, None)?;
|
||||
// The credential is not published until its Windows owner is retained.
|
||||
self
|
||||
.sessions
|
||||
.lock()
|
||||
.map_err(|_| SessionError::Unavailable)?
|
||||
.get_mut(&credential.session_id())
|
||||
.ok_or(SessionError::Unauthorized)?
|
||||
.windows_identity = Some(identity);
|
||||
Ok(credential)
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
pub(crate) fn windows_identity(
|
||||
&self,
|
||||
session_id: Uuid,
|
||||
) -> Result<Arc<gpapi::windows::PipeClientIdentity>, SessionError> {
|
||||
self
|
||||
.sessions
|
||||
.lock()
|
||||
.map_err(|_| SessionError::Unavailable)?
|
||||
.get(&session_id)
|
||||
.and_then(|record| record.windows_identity.clone())
|
||||
.ok_or(SessionError::Unauthorized)
|
||||
}
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
pub fn is_empty(&self) -> bool {
|
||||
let Ok(mut sessions) = self.sessions.lock() else {
|
||||
|
||||
@@ -1,6 +1,9 @@
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[path = "privileged_unix.rs"]
|
||||
mod platform;
|
||||
#[cfg(windows)]
|
||||
#[path = "windows.rs"]
|
||||
mod platform;
|
||||
#[cfg(target_os = "macos")]
|
||||
#[path = "macos.rs"]
|
||||
mod platform;
|
||||
@@ -8,7 +11,8 @@ mod platform;
|
||||
target_os = "linux",
|
||||
target_os = "freebsd",
|
||||
target_os = "openbsd",
|
||||
target_os = "macos"
|
||||
target_os = "macos",
|
||||
windows
|
||||
)))]
|
||||
#[path = "default.rs"]
|
||||
mod platform;
|
||||
@@ -16,3 +20,5 @@ mod platform;
|
||||
mod selection;
|
||||
|
||||
pub(crate) use platform::builder;
|
||||
#[cfg(windows)]
|
||||
pub(crate) use platform::recover_network;
|
||||
@@ -0,0 +1,24 @@
|
||||
use gpapi::service::request::ConnectArgs;
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
use std::sync::Mutex;
|
||||
const RECOVERY_KEY: &str = r"SOFTWARE\GP Connect\NetworkRecovery";
|
||||
|
||||
pub(crate) fn recover_network() -> std::io::Result<()> {
|
||||
gpvpnc::windows::recover(RECOVERY_KEY)
|
||||
}
|
||||
|
||||
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> anyhow::Result<VpnBuilder> {
|
||||
anyhow::ensure!(
|
||||
args.vpnc_script().is_none(),
|
||||
"Windows does not support custom VPN scripts"
|
||||
);
|
||||
let network = Mutex::new(gpvpnc::windows::NetworkConfigurator::new(RECOVERY_KEY)?);
|
||||
Ok(
|
||||
Vpn::builder(server, cookie).network_configuration_handler(move |configuration| {
|
||||
network
|
||||
.lock()
|
||||
.map_err(|_| std::io::Error::other("Windows network state is unavailable"))?
|
||||
.configure(&configuration.reason, &configuration.environment)
|
||||
}),
|
||||
)
|
||||
}
|
||||
@@ -126,6 +126,7 @@ impl LifecycleHandle {
|
||||
ServiceResult::Accepted
|
||||
}
|
||||
|
||||
#[cfg(any(unix, test))]
|
||||
pub async fn disconnect_and_wait(&self) -> bool {
|
||||
let completion = {
|
||||
let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned");
|
||||
@@ -447,7 +448,7 @@ pub(crate) struct VpnTask {
|
||||
events: mpsc::Receiver<LifecycleEvent>,
|
||||
lifecycle: LifecycleHandle,
|
||||
vpn_state_tx: watch::Sender<VpnState>,
|
||||
brokered_macos: bool,
|
||||
restricted_desktop: bool,
|
||||
registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
active: Option<ActiveAttempt>,
|
||||
cancel_token: CancellationToken,
|
||||
@@ -456,7 +457,7 @@ pub(crate) struct VpnTask {
|
||||
impl VpnTask {
|
||||
pub fn new(
|
||||
vpn_state_tx: watch::Sender<VpnState>,
|
||||
brokered_macos: bool,
|
||||
restricted_desktop: bool,
|
||||
registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
) -> (Self, LifecycleHandle) {
|
||||
let (events_tx, events) = mpsc::channel(4);
|
||||
@@ -470,7 +471,7 @@ impl VpnTask {
|
||||
events,
|
||||
lifecycle: lifecycle.clone(),
|
||||
vpn_state_tx,
|
||||
brokered_macos,
|
||||
restricted_desktop,
|
||||
registry,
|
||||
active: None,
|
||||
cancel_token: CancellationToken::new(),
|
||||
@@ -617,7 +618,7 @@ impl VpnTask {
|
||||
desktop_uid,
|
||||
edited_report,
|
||||
session_id,
|
||||
brokered_macos: self.brokered_macos,
|
||||
restricted_desktop: self.restricted_desktop,
|
||||
registry: self.registry.clone(),
|
||||
lifecycle: self.lifecycle.clone(),
|
||||
},
|
||||
|
||||
@@ -30,7 +30,7 @@ pub(super) struct ConnectionResources {
|
||||
/// the complete ledger and its retained identity resources to the service.
|
||||
pub(crate) async fn prepare_connection(
|
||||
request: ConnectRequest,
|
||||
brokered_macos: bool,
|
||||
restricted_desktop: bool,
|
||||
cancellation: CancellationToken,
|
||||
) -> anyhow::Result<PreparedConnection> {
|
||||
let mode = request.args().packet_delivery().clone();
|
||||
@@ -77,11 +77,16 @@ pub(crate) async fn prepare_connection(
|
||||
};
|
||||
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 = super::prepare_identity(args, restricted_desktop || non_tunnel)?;
|
||||
#[cfg(target_os = "macos")]
|
||||
let directory = restricted_desktop.then(|| std::path::PathBuf::from("/var/run/com.yuezk.gpgui"));
|
||||
#[cfg(windows)]
|
||||
let directory = Some(common::paths::service_private_dir());
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
let directory: Option<std::path::PathBuf> = None;
|
||||
let identity_files = identity
|
||||
.as_ref()
|
||||
.map(|identity| identity.write_files(directory))
|
||||
.map(|identity| identity.write_files(directory.as_deref()))
|
||||
.transpose()?;
|
||||
let host = args.host_identity().context("Authenticated host identity is missing")?;
|
||||
let profile = crate::hip_source::profile(
|
||||
@@ -181,8 +186,8 @@ mod tests {
|
||||
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)] {
|
||||
async fn restricted_desktop_and_non_tunnel_identity_reject_path_handoff() {
|
||||
for (restricted_desktop, 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()));
|
||||
@@ -192,7 +197,7 @@ mod tests {
|
||||
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())
|
||||
let error = prepare_connection(request, restricted_desktop, CancellationToken::new())
|
||||
.await
|
||||
.err()
|
||||
.unwrap();
|
||||
|
||||
@@ -20,7 +20,7 @@ pub(super) struct AttemptInput {
|
||||
pub desktop_uid: Option<u32>,
|
||||
pub edited_report: Option<Arc<str>>,
|
||||
pub session_id: Option<Uuid>,
|
||||
pub brokered_macos: bool,
|
||||
pub restricted_desktop: bool,
|
||||
pub registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
pub lifecycle: LifecycleHandle,
|
||||
}
|
||||
@@ -31,6 +31,7 @@ struct TunnelInput {
|
||||
source: Arc<openconnect::HipSource>,
|
||||
session_id: Option<Uuid>,
|
||||
registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
#[cfg(unix)]
|
||||
desktop_uid: Option<u32>,
|
||||
}
|
||||
|
||||
@@ -55,7 +56,7 @@ pub(super) fn spawn(
|
||||
let request = input.connection.request.clone();
|
||||
let resources = input.connection.resources.clone();
|
||||
let desktop_uid = input.desktop_uid;
|
||||
let brokered = input.brokered_macos;
|
||||
let brokered = input.restricted_desktop;
|
||||
let edited = input.edited_report.clone();
|
||||
let setup_cancel = cancellation.clone();
|
||||
let execution = tokio::task::spawn_blocking(move || {
|
||||
@@ -105,6 +106,7 @@ pub(super) fn spawn(
|
||||
source,
|
||||
session_id: input.session_id,
|
||||
registry: input.registry.clone(),
|
||||
#[cfg(unix)]
|
||||
desktop_uid: input.desktop_uid,
|
||||
};
|
||||
input.connection.request.release_script_tun_bootstrap();
|
||||
@@ -253,12 +255,14 @@ fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyho
|
||||
),
|
||||
gpapi::script_tun::PacketDelivery::ScriptTun(request) => {
|
||||
ensure!(input.session_id.is_some(), "Script-tun requires a desktop session");
|
||||
let (builder, script_tun) = super::script_tun::builder(
|
||||
member.gateway.server(),
|
||||
member.authentication.cookie(),
|
||||
request,
|
||||
input.desktop_uid.context("Desktop identity is unavailable")?,
|
||||
)?;
|
||||
#[cfg(unix)]
|
||||
let owner = input.desktop_uid.context("Desktop identity is unavailable")?;
|
||||
#[cfg(windows)]
|
||||
let owner = input
|
||||
.registry
|
||||
.windows_identity(input.session_id.context("Desktop session is unavailable")?)?;
|
||||
let (builder, script_tun) =
|
||||
super::script_tun::builder(member.gateway.server(), member.authentication.cookie(), request, owner)?;
|
||||
(builder, Some(script_tun))
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1,40 +1,19 @@
|
||||
//! Supervision of an unprivileged script-tun consumer; payload semantics belong to the caller.
|
||||
use super::{LifecycleEvent, LifecycleHandle};
|
||||
use anyhow::{Context, bail, ensure};
|
||||
use gpapi::script_tun::{Bootstrap, Identity, Message, ScriptTunRequest, receive, send as send_message};
|
||||
use openconnect::{Vpn, VpnBuilder, tunnel::Event};
|
||||
use gpapi::script_tun::{Bootstrap, Identity, Message, receive, send as send_message};
|
||||
use openconnect::{Vpn, tunnel::Event};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
use tokio::{net::UnixStream, sync::mpsc, time::Instant};
|
||||
use tokio::{sync::mpsc, time::Instant};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
pub(super) struct PreparedScriptTun {
|
||||
pub control: std::os::unix::net::UnixStream,
|
||||
pub bootstrap: Bootstrap,
|
||||
}
|
||||
|
||||
pub(super) fn builder(
|
||||
server: &str,
|
||||
cookie: &str,
|
||||
request: &ScriptTunRequest,
|
||||
uid: u32,
|
||||
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
|
||||
request.validate()?;
|
||||
ensure!(uid != 0, "Script-tun worker requires a desktop user");
|
||||
let (control, child) = std::os::unix::net::UnixStream::pair()?;
|
||||
let builder = Vpn::builder(server, cookie).script_tun_program(
|
||||
request.program.to_str().context("Program is not UTF-8")?,
|
||||
&request.args,
|
||||
uid,
|
||||
child.into(),
|
||||
)?;
|
||||
Ok((
|
||||
builder,
|
||||
PreparedScriptTun {
|
||||
control,
|
||||
bootstrap: request.bootstrap.clone(),
|
||||
},
|
||||
))
|
||||
}
|
||||
#[cfg(unix)]
|
||||
#[path = "script_tun/unix.rs"]
|
||||
mod platform;
|
||||
#[cfg(windows)]
|
||||
#[path = "script_tun/windows.rs"]
|
||||
mod platform;
|
||||
pub(super) use platform::{PreparedScriptTun, builder};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(super) struct NetworkChanged;
|
||||
@@ -53,7 +32,7 @@ enum Native {
|
||||
pub(super) async fn run(
|
||||
identity: Identity,
|
||||
vpn: Arc<Vpn>,
|
||||
prepared: PreparedScriptTun,
|
||||
mut prepared: PreparedScriptTun,
|
||||
approval: &crate::hip_source::HipApproval,
|
||||
lifecycle: &LifecycleHandle,
|
||||
cancellation: CancellationToken,
|
||||
@@ -62,6 +41,8 @@ pub(super) async fn run(
|
||||
registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
sessions: &mut gpapi::session::desktop::GatewaySessions,
|
||||
) -> anyhow::Result<()> {
|
||||
let channel = prepared.connect().await?;
|
||||
let mut control = ConsumerControl::new(channel);
|
||||
let attempt = identity.attempt;
|
||||
let (native_tx, native) = mpsc::channel(64);
|
||||
let observed = native_tx.clone();
|
||||
@@ -77,7 +58,7 @@ pub(super) async fn run(
|
||||
monitor: monitor.clone(),
|
||||
})
|
||||
.await;
|
||||
if event_result.is_err() {
|
||||
if event_result.is_err() || cancellation.is_cancelled() {
|
||||
monitor.stop().await;
|
||||
return Ok(());
|
||||
}
|
||||
@@ -91,31 +72,50 @@ pub(super) async fn run(
|
||||
tokio::pin!(worker);
|
||||
let mut worker_done = false;
|
||||
let stop = cancellation.child_token();
|
||||
let supervisor = supervise(identity, prepared, native, stop.clone(), events);
|
||||
tokio::pin!(supervisor);
|
||||
let mut supervisor_done = false;
|
||||
let mut approval_poll = tokio::time::interval(Duration::from_millis(250));
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
result = &mut supervisor => { supervisor_done = true; break result; }
|
||||
result = &mut worker => { worker_done = true; break Err(anyhow::anyhow!("VPN worker ended: {:?}", result)); }
|
||||
_ = approval_poll.tick() => {
|
||||
if !approval.approval_is_valid() || !registry.has_session(session_id) {
|
||||
super::runtime::stop_for_revoked_approval(lifecycle, &cancellation);
|
||||
let result = {
|
||||
let supervisor = supervise(
|
||||
identity,
|
||||
&mut control,
|
||||
std::mem::take(&mut prepared.bootstrap),
|
||||
native,
|
||||
stop.clone(),
|
||||
events,
|
||||
);
|
||||
tokio::pin!(supervisor);
|
||||
let mut supervisor_done = false;
|
||||
let mut approval_poll = tokio::time::interval(Duration::from_millis(250));
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
result = &mut supervisor => { supervisor_done = true; break result; }
|
||||
result = &mut worker => { worker_done = true; break Err(anyhow::anyhow!("VPN worker ended: {:?}", result)); }
|
||||
_ = approval_poll.tick() => {
|
||||
if !approval.approval_is_valid() || !registry.has_session(session_id) {
|
||||
super::runtime::stop_for_revoked_approval(lifecycle, &cancellation);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
stop.cancel();
|
||||
// Keep the consumer's control and packet endpoints alive until OpenConnect
|
||||
// consumes cancellation and logs out. Early EOF would interrupt that logout.
|
||||
vpn.disconnect();
|
||||
if !worker_done {
|
||||
let _ = worker.await;
|
||||
}
|
||||
if !supervisor_done {
|
||||
let _ = supervisor.await;
|
||||
}
|
||||
result
|
||||
};
|
||||
stop.cancel();
|
||||
if !supervisor_done {
|
||||
let _ = supervisor.await;
|
||||
}
|
||||
vpn.disconnect();
|
||||
if !worker_done {
|
||||
let _ = worker.await;
|
||||
}
|
||||
control.stop().await;
|
||||
let cleanup = prepared.stop_worker();
|
||||
monitor.stop().await;
|
||||
if result.is_ok() {
|
||||
cleanup?;
|
||||
} else if let Err(error) = cleanup {
|
||||
log::warn!("Could not stop packet worker: {error:#}");
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
@@ -128,93 +128,113 @@ enum WorkerState {
|
||||
Suspending,
|
||||
}
|
||||
|
||||
// The same control loop runs against native observations in production and a
|
||||
// generic socket consumer in tests; VPN ownership stays in run().
|
||||
// Own the channel independently of its supervision future so run() can drain
|
||||
// the native VPN before telling the consumer to stop or closing its endpoints.
|
||||
struct ConsumerControl {
|
||||
output: tokio::io::WriteHalf<platform::ControlStream>,
|
||||
messages: mpsc::Receiver<std::io::Result<Message>>,
|
||||
reader: tokio::task::JoinHandle<()>,
|
||||
}
|
||||
impl ConsumerControl {
|
||||
fn new(channel: platform::ControlStream) -> Self {
|
||||
let (mut input, output) = tokio::io::split(channel);
|
||||
let (messages_tx, messages) = mpsc::channel(8);
|
||||
let reader = tokio::spawn(async move {
|
||||
loop {
|
||||
let message = receive(&mut input).await;
|
||||
let failed = message.is_err();
|
||||
if messages_tx.send(message).await.is_err() || failed {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
Self {
|
||||
output,
|
||||
messages,
|
||||
reader,
|
||||
}
|
||||
}
|
||||
async fn stop(&mut self) {
|
||||
let _ = tokio::time::timeout(Duration::from_millis(250), send(&mut self.output, &Message::Stop)).await;
|
||||
self.reader.abort();
|
||||
let _ = (&mut self.reader).await;
|
||||
}
|
||||
}
|
||||
impl Drop for ConsumerControl {
|
||||
fn drop(&mut self) {
|
||||
self.reader.abort();
|
||||
}
|
||||
}
|
||||
|
||||
// Production and generic-consumer tests exercise this same state machine.
|
||||
async fn supervise(
|
||||
identity: Identity,
|
||||
mut prepared: PreparedScriptTun,
|
||||
control: &mut ConsumerControl,
|
||||
mut bootstrap: Bootstrap,
|
||||
mut native: mpsc::Receiver<Native>,
|
||||
cancellation: CancellationToken,
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
) -> anyhow::Result<()> {
|
||||
let attempt = identity.attempt;
|
||||
prepared.control.set_nonblocking(true)?;
|
||||
let control = UnixStream::from_std(prepared.control)?;
|
||||
let (mut input, mut output) = control.into_split();
|
||||
let (messages_tx, mut messages) = mpsc::channel(8);
|
||||
let reader = tokio::spawn(async move {
|
||||
loop {
|
||||
let message = receive(&mut input).await;
|
||||
let failed = message.is_err();
|
||||
if messages_tx.send(message).await.is_err() || failed {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
let ConsumerControl { output, messages, .. } = control;
|
||||
let mut network = None;
|
||||
let mut session = None;
|
||||
let mut worker = WorkerState::Preparing;
|
||||
let mut online = false;
|
||||
let mut was_connected = false;
|
||||
let mut deadline: Option<Instant> = None;
|
||||
let result = async {
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = cancellation.cancelled() => break,
|
||||
_ = async { if let Some(at) = deadline { tokio::time::sleep_until(at).await } else { std::future::pending().await } } => bail!("Script-tun worker activation timed out"),
|
||||
message = messages.recv() => match message.context("Script-tun control reader stopped")?? {
|
||||
Message::Ready if worker == WorkerState::Preparing && network.is_some() => {
|
||||
worker = WorkerState::Ready;
|
||||
}
|
||||
Message::Activated if worker == WorkerState::Activating => {
|
||||
ensure!(online, "Script-tun activation completed while VPN was offline");
|
||||
ensure!(!cancellation.is_cancelled(), "Script-tun startup cancelled");
|
||||
events.send(LifecycleEvent::Established { attempt, session: session.clone().context("Native session is missing")? }).await?;
|
||||
worker = WorkerState::Active; was_connected = true; deadline = None;
|
||||
}
|
||||
Message::Suspended if worker == WorkerState::Suspending => { worker = WorkerState::Ready; deadline = None; }
|
||||
Message::Error { message } => bail!("Script-tun worker: {message}"),
|
||||
_ => bail!("Unexpected script-tun consumer message"),
|
||||
},
|
||||
event = native.recv() => match event.context("Native event stream ended")? {
|
||||
Native::Established(value) => { session = Some(value); online = true; deadline.get_or_insert(Instant::now() + Duration::from_secs(10)); }
|
||||
Native::Event(Event::Configuration(config)) => {
|
||||
let observed = config.context("VPN configuration is absent").and_then(observed_network);
|
||||
if was_connected && (observed.is_err() || network.as_ref().is_some_and(|old| observed.as_ref().is_ok_and(|new| old != new))) { return Err(NetworkChanged.into()); }
|
||||
let observed = observed?;
|
||||
if let Some(old) = &network { ensure!(old == &observed, "VPN configuration changed during startup"); }
|
||||
else {
|
||||
send(&mut output, &Message::Configure { identity, bootstrap: std::mem::take(&mut prepared.bootstrap), network: observed.clone() }).await?;
|
||||
network = Some(observed);
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Native::Event(Event::Reconnecting) => {
|
||||
ensure!(worker != WorkerState::Activating, "VPN connection interrupted during script-tun activation; reconnect the VPN");
|
||||
online = false;
|
||||
events.send(LifecycleEvent::ScriptTunSuspended { attempt }).await?;
|
||||
if matches!(worker, WorkerState::Ready | WorkerState::Active) {
|
||||
send(&mut output, &Message::Suspend).await?; worker = WorkerState::Suspending;
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Native::Event(Event::Reconnected) => online = true,
|
||||
Native::Event(_) => {},
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = cancellation.cancelled() => break,
|
||||
_ = async { if let Some(at) = deadline { tokio::time::sleep_until(at).await } else { std::future::pending().await } } => bail!("Script-tun worker activation timed out"),
|
||||
message = messages.recv() => match message.context("Script-tun control reader stopped")?? {
|
||||
Message::Ready if worker == WorkerState::Preparing && network.is_some() => {
|
||||
worker = WorkerState::Ready;
|
||||
}
|
||||
}
|
||||
if online && session.is_some() && worker == WorkerState::Ready && !cancellation.is_cancelled() {
|
||||
send(&mut output, &Message::Activate).await?; worker = WorkerState::Activating;
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
Message::Activated if worker == WorkerState::Activating => {
|
||||
ensure!(online, "Script-tun activation completed while VPN was offline");
|
||||
ensure!(!cancellation.is_cancelled(), "Script-tun startup cancelled");
|
||||
events.send(LifecycleEvent::Established { attempt, session: session.clone().context("Native session is missing")? }).await?;
|
||||
worker = WorkerState::Active; was_connected = true; deadline = None;
|
||||
}
|
||||
Message::Suspended if worker == WorkerState::Suspending => { worker = WorkerState::Ready; deadline = None; }
|
||||
Message::Error { message } => bail!("Script-tun worker: {message}"),
|
||||
_ => bail!("Unexpected script-tun consumer message"),
|
||||
},
|
||||
event = native.recv() => match event.context("Native event stream ended")? {
|
||||
Native::Established(value) => { session = Some(value); online = true; deadline.get_or_insert(Instant::now() + Duration::from_secs(10)); }
|
||||
Native::Event(Event::Configuration(config)) => {
|
||||
let observed = config.context("VPN configuration is absent").and_then(observed_network);
|
||||
if was_connected && (observed.is_err() || network.as_ref().is_some_and(|old| observed.as_ref().is_ok_and(|new| old != new))) { return Err(NetworkChanged.into()); }
|
||||
let observed = observed?;
|
||||
if let Some(old) = &network { ensure!(old == &observed, "VPN configuration changed during startup"); }
|
||||
else {
|
||||
send(output, &Message::Configure { identity, bootstrap: std::mem::take(&mut bootstrap), network: observed.clone() }).await?;
|
||||
network = Some(observed);
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Native::Event(Event::Reconnecting) => {
|
||||
ensure!(worker != WorkerState::Activating, "VPN connection interrupted during script-tun activation; reconnect the VPN");
|
||||
online = false;
|
||||
events.send(LifecycleEvent::ScriptTunSuspended { attempt }).await?;
|
||||
if matches!(worker, WorkerState::Ready | WorkerState::Active) {
|
||||
send(output, &Message::Suspend).await?; worker = WorkerState::Suspending;
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Native::Event(Event::Reconnected) => online = true,
|
||||
Native::Event(_) => {},
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}.await;
|
||||
let _ = tokio::time::timeout(Duration::from_millis(250), send(&mut output, &Message::Stop)).await;
|
||||
drop(output);
|
||||
reader.abort();
|
||||
let _ = reader.await;
|
||||
result
|
||||
if online && session.is_some() && worker == WorkerState::Ready && !cancellation.is_cancelled() {
|
||||
send(output, &Message::Activate).await?;
|
||||
worker = WorkerState::Activating;
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn observed_network(
|
||||
@@ -243,5 +263,5 @@ async fn send(writer: &mut (impl tokio::io::AsyncWrite + Unpin), message: &Messa
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
#[cfg(all(test, unix))]
|
||||
mod tests;
|
||||
@@ -1,6 +1,8 @@
|
||||
use super::*;
|
||||
use gpapi::script_tun::{Bootstrap, ScriptTunRequest};
|
||||
use openconnect::{VpnSessionInfo, tunnel::Configuration};
|
||||
use tokio::io::AsyncWriteExt;
|
||||
use tokio::net::UnixStream;
|
||||
|
||||
// A generic consumer, with no proxy settings or private worker protocol.
|
||||
struct Consumer {
|
||||
@@ -23,16 +25,26 @@ impl Consumer {
|
||||
launch_id: uuid::Uuid::new_v4(),
|
||||
};
|
||||
let cancel = CancellationToken::new();
|
||||
let task = tokio::spawn(supervise(
|
||||
identity,
|
||||
PreparedScriptTun {
|
||||
control,
|
||||
let stopped = cancel.clone();
|
||||
let task = tokio::spawn(async move {
|
||||
let mut prepared = PreparedScriptTun {
|
||||
control: Some(control),
|
||||
bootstrap: Bootstrap::new(b"consumer bootstrap").unwrap(),
|
||||
},
|
||||
observations,
|
||||
cancel.clone(),
|
||||
events,
|
||||
));
|
||||
};
|
||||
let channel = prepared.connect().await?;
|
||||
let mut control = ConsumerControl::new(channel);
|
||||
let result = supervise(
|
||||
identity,
|
||||
&mut control,
|
||||
prepared.bootstrap,
|
||||
observations,
|
||||
stopped,
|
||||
events,
|
||||
)
|
||||
.await;
|
||||
control.stop().await;
|
||||
result
|
||||
});
|
||||
Self {
|
||||
control: UnixStream::from_std(child).unwrap(),
|
||||
native,
|
||||
@@ -291,3 +303,36 @@ async fn reconnect_during_activation_returns_clear_error_without_connected() {
|
||||
);
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn supervision_completion_keeps_consumer_alive_until_owner_stops_it() {
|
||||
let (channel, mut peer) = UnixStream::pair().unwrap();
|
||||
let mut control = ConsumerControl::new(channel);
|
||||
let (_native, observations) = mpsc::channel(1);
|
||||
let (events, _notifications) = mpsc::channel(1);
|
||||
let cancellation = CancellationToken::new();
|
||||
cancellation.cancel();
|
||||
supervise(
|
||||
Identity {
|
||||
service_instance: uuid::Uuid::new_v4(),
|
||||
attempt: 1,
|
||||
launch_id: uuid::Uuid::new_v4(),
|
||||
},
|
||||
&mut control,
|
||||
Bootstrap::default(),
|
||||
observations,
|
||||
cancellation,
|
||||
events,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_millis(30), receive(&mut peer))
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
control.stop().await;
|
||||
assert!(matches!(receive(&mut peer).await.unwrap(), Message::Stop));
|
||||
drop(control);
|
||||
assert!(receive(&mut peer).await.is_err());
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::script_tun::{Bootstrap, ScriptTunRequest};
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
pub(super) type ControlStream = tokio::net::UnixStream;
|
||||
pub(crate) struct PreparedScriptTun {
|
||||
pub(super) control: Option<std::os::unix::net::UnixStream>,
|
||||
pub bootstrap: Bootstrap,
|
||||
}
|
||||
|
||||
pub(crate) fn builder(
|
||||
server: &str,
|
||||
cookie: &str,
|
||||
request: &ScriptTunRequest,
|
||||
uid: u32,
|
||||
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
|
||||
request.validate()?;
|
||||
ensure!(uid != 0, "Script-tun worker requires a desktop user");
|
||||
let (control, child) = std::os::unix::net::UnixStream::pair()?;
|
||||
let builder = Vpn::builder(server, cookie).script_tun_program(
|
||||
request.program.to_str().context("Program is not UTF-8")?,
|
||||
&request.args,
|
||||
uid,
|
||||
child.into(),
|
||||
)?;
|
||||
Ok((
|
||||
builder,
|
||||
PreparedScriptTun {
|
||||
control: Some(control),
|
||||
bootstrap: request.bootstrap.clone(),
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
impl PreparedScriptTun {
|
||||
pub(super) async fn connect(&mut self) -> anyhow::Result<ControlStream> {
|
||||
let control = self.control.take().context("Worker control pipe is unavailable")?;
|
||||
control.set_nonblocking(true)?;
|
||||
Ok(tokio::net::UnixStream::from_std(control)?)
|
||||
}
|
||||
// The native OpenConnect Unix launcher owns/reaps its child on disconnect.
|
||||
pub(super) fn stop_worker(&mut self) -> anyhow::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::{
|
||||
process::user_process::UserProcess,
|
||||
script_tun::{Bootstrap, ScriptTunRequest},
|
||||
windows::PipeClientIdentity,
|
||||
};
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
use std::{os::windows::io::AsRawHandle, sync::Arc, time::Duration};
|
||||
use tokio::net::windows::named_pipe::NamedPipeServer;
|
||||
use windows_sys::Win32::System::Pipes::GetNamedPipeClientProcessId;
|
||||
pub(super) type ControlStream = NamedPipeServer;
|
||||
|
||||
pub(crate) struct PreparedScriptTun {
|
||||
control: Option<NamedPipeServer>,
|
||||
worker: UserProcess,
|
||||
pub(super) bootstrap: Bootstrap,
|
||||
}
|
||||
pub(crate) fn builder(
|
||||
server: &str,
|
||||
cookie: &str,
|
||||
request: &ScriptTunRequest,
|
||||
owner: Arc<PipeClientIdentity>,
|
||||
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
|
||||
request.validate()?;
|
||||
let attempt = uuid::Uuid::new_v4();
|
||||
let control_name = format!(r"\\.\pipe\GPConnect.ScriptTun.{attempt}.Control");
|
||||
let packet_name = format!(r"\\.\pipe\GPConnect.ScriptTun.{attempt}.Packets");
|
||||
let control = owner.create_control_pipe(&control_name)?;
|
||||
let mut packets = owner.create_packet_pipe(&packet_name)?;
|
||||
let worker = UserProcess::launch(
|
||||
owner.primary_token(),
|
||||
&request.program,
|
||||
&request.args,
|
||||
&[
|
||||
("OPENCONNECT_SCRIPT_TUN_CONTROL_PIPE", &control_name),
|
||||
("VPN_PIPE", &packet_name),
|
||||
],
|
||||
)
|
||||
.context("Could not launch the user-session packet worker")?;
|
||||
packets.connect(worker.id(), Duration::from_secs(10))?;
|
||||
// PacketPipe creates only raw overlapped Win32 I/O and never registers IOCP.
|
||||
let builder = unsafe { Vpn::builder(server, cookie).script_tun_pipe(packets.into_handle()) };
|
||||
Ok((
|
||||
builder,
|
||||
PreparedScriptTun {
|
||||
control: Some(control),
|
||||
worker,
|
||||
bootstrap: request.bootstrap.clone(),
|
||||
},
|
||||
))
|
||||
}
|
||||
impl PreparedScriptTun {
|
||||
pub(super) async fn connect(&mut self) -> anyhow::Result<ControlStream> {
|
||||
ensure!(!self.worker.has_exited()?, "The packet worker exited during startup");
|
||||
let control = self.control.take().context("Worker control pipe is unavailable")?;
|
||||
tokio::time::timeout(Duration::from_secs(10), control.connect())
|
||||
.await
|
||||
.context("Packet control connection timed out")??;
|
||||
let mut pid = 0;
|
||||
if unsafe { GetNamedPipeClientProcessId(control.as_raw_handle(), &mut pid) } == 0 {
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
}
|
||||
ensure!(pid == self.worker.id(), "Unexpected packet control client");
|
||||
Ok(control)
|
||||
}
|
||||
pub(super) fn stop_worker(&mut self) -> anyhow::Result<()> {
|
||||
Ok(self.worker.stop()?)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
//! A credential lease binds the existing desktop session to its Windows token.
|
||||
use crate::session_registry::SessionRegistry;
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::{
|
||||
service::transport::WINDOWS_ADMISSION_REQUEST,
|
||||
windows::{PipeClientIdentity, create_service_admission_pipe},
|
||||
};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
use tokio::{
|
||||
io::{AsyncReadExt, AsyncWriteExt},
|
||||
net::windows::named_pipe::NamedPipeServer,
|
||||
task::JoinSet,
|
||||
};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
pub(super) struct Admission {
|
||||
listener: NamedPipeServer,
|
||||
registry: Arc<SessionRegistry>,
|
||||
}
|
||||
struct Lease {
|
||||
registry: Arc<SessionRegistry>,
|
||||
session: uuid::Uuid,
|
||||
}
|
||||
impl Drop for Lease {
|
||||
fn drop(&mut self) {
|
||||
self.registry.revoke(self.session);
|
||||
}
|
||||
}
|
||||
impl Admission {
|
||||
pub fn new(registry: Arc<SessionRegistry>) -> anyhow::Result<Self> {
|
||||
Ok(Self {
|
||||
listener: create_service_admission_pipe(true)?,
|
||||
registry,
|
||||
})
|
||||
}
|
||||
pub async fn run(mut self, cancel: CancellationToken) -> anyhow::Result<()> {
|
||||
let mut clients = JoinSet::new();
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
_ = cancel.cancelled() => break Ok(()),
|
||||
result = self.listener.connect() => {
|
||||
if let Err(error) = result { break Err(error.into()); }
|
||||
let next = match create_service_admission_pipe(false) { Ok(next) => next, Err(error) => break Err(error.into()) };
|
||||
let pipe = std::mem::replace(&mut self.listener, next);
|
||||
let registry = self.registry.clone();
|
||||
let cancel = cancel.clone();
|
||||
clients.spawn(async move {
|
||||
if let Err(error) = serve(pipe, registry, cancel).await { log::warn!("Desktop credential lease ended: {error:#}"); }
|
||||
});
|
||||
}
|
||||
_ = clients.join_next(), if !clients.is_empty() => {},
|
||||
}
|
||||
};
|
||||
// Drop each lease before the shared registry and service runtime disappear.
|
||||
clients.abort_all();
|
||||
while clients.join_next().await.is_some() {}
|
||||
result
|
||||
}
|
||||
}
|
||||
async fn serve(
|
||||
mut pipe: NamedPipeServer,
|
||||
registry: Arc<SessionRegistry>,
|
||||
cancel: CancellationToken,
|
||||
) -> anyhow::Result<()> {
|
||||
let mut request = [0; WINDOWS_ADMISSION_REQUEST.len()];
|
||||
tokio::select! {
|
||||
_ = cancel.cancelled() => return Ok(()),
|
||||
result = tokio::time::timeout(Duration::from_secs(10), pipe.read_exact(&mut request)) => { result.context("Desktop admission timed out")??; }
|
||||
}
|
||||
ensure!(
|
||||
request == WINDOWS_ADMISSION_REQUEST,
|
||||
"Invalid desktop admission request"
|
||||
);
|
||||
// This synchronous call impersonates, duplicates and reverts before any await.
|
||||
let identity = Arc::new(PipeClientIdentity::from_pipe(&pipe)?);
|
||||
let credential = registry.issue_windows(env!("CARGO_PKG_VERSION"), identity)?;
|
||||
let _lease = Lease {
|
||||
registry,
|
||||
session: credential.session_id(),
|
||||
};
|
||||
let frame = credential.encode_frame()?;
|
||||
tokio::select! {
|
||||
_ = cancel.cancelled() => return Ok(()),
|
||||
result = tokio::time::timeout(Duration::from_secs(10), pipe.write_all(&frame)) => { result.context("Desktop credential delivery timed out")??; }
|
||||
}
|
||||
let mut byte = [0];
|
||||
tokio::select! {
|
||||
_ = cancel.cancelled() => {},
|
||||
result = pipe.read(&mut byte) => { ensure!(result? == 0, "Unexpected desktop lease message"); }
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
use std::{fs::OpenOptions, io, path::Path};
|
||||
|
||||
use file_rotate::{ContentLimit, FileRotate, compression::Compression, suffix::AppendCount};
|
||||
|
||||
const ROTATE_BYTES: usize = 5 * 1024 * 1024;
|
||||
const ARCHIVE_COUNT: usize = 3;
|
||||
|
||||
pub(super) fn writer(path: &Path) -> io::Result<FileRotate<AppendCount>> {
|
||||
// Keep startup failure explicit: FileRotate's constructor suppresses open errors.
|
||||
OpenOptions::new().create(true).read(true).append(true).open(path)?;
|
||||
Ok(FileRotate::new(
|
||||
path,
|
||||
AppendCount::new(ARCHIVE_COUNT),
|
||||
ContentLimit::BytesSurpassed(ROTATE_BYTES),
|
||||
Compression::None,
|
||||
None,
|
||||
))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::{fs, io::Write};
|
||||
|
||||
#[test]
|
||||
fn keeps_the_latest_three_archives_and_complete_current_entry() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("gpservice.log");
|
||||
fs::write(dir.path().join("unrelated.log"), "keep").unwrap();
|
||||
let mut log = writer(&path).unwrap();
|
||||
for marker in b'0'..=b'5' {
|
||||
log.write_all(&vec![marker; ROTATE_BYTES + 1]).unwrap();
|
||||
}
|
||||
log.flush().unwrap();
|
||||
drop(log);
|
||||
|
||||
assert_eq!(fs::read(&path).unwrap(), vec![b'5'; ROTATE_BYTES + 1]);
|
||||
for (suffix, marker) in [(1, b'4'), (2, b'3'), (3, b'2')] {
|
||||
let archive = dir.path().join(format!("gpservice.log.{suffix}"));
|
||||
assert_eq!(fs::read(archive).unwrap(), vec![marker; ROTATE_BYTES + 1]);
|
||||
}
|
||||
assert_eq!(fs::read_dir(dir.path()).unwrap().count(), 5);
|
||||
assert_eq!(fs::read_to_string(dir.path().join("unrelated.log")).unwrap(), "keep");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn restart_appends_and_accounts_for_existing_file_size() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let path = dir.path().join("gpservice.log");
|
||||
fs::write(&path, "before restart\n").unwrap();
|
||||
{
|
||||
let mut log = writer(&path).unwrap();
|
||||
log.write_all(b"after restart\n").unwrap();
|
||||
}
|
||||
assert_eq!(fs::read_to_string(&path).unwrap(), "before restart\nafter restart\n");
|
||||
|
||||
let entry = vec![b'x'; ROTATE_BYTES + 1];
|
||||
fs::write(&path, &entry).unwrap();
|
||||
{
|
||||
let mut log = writer(&path).unwrap();
|
||||
log.write_all(b"new entry\n").unwrap();
|
||||
}
|
||||
assert_eq!(fs::read(&path).unwrap(), b"new entry\n");
|
||||
assert_eq!(fs::read(dir.path().join("gpservice.log.1")).unwrap(), entry);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_log_path_remains_a_startup_error() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
assert!(writer(dir.path()).is_err());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
//! Service Control Manager hosting; the GUI remains in the user's desktop session.
|
||||
mod admission;
|
||||
mod logging;
|
||||
use crate::{
|
||||
request_dispatcher::RequestDispatcher, session_registry::SessionRegistry, vpn_task::VpnTask, ws_server::WsServer,
|
||||
};
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::{
|
||||
service::vpn_state::VpnState,
|
||||
utils::{lock_file::LockFile, redact::Redaction},
|
||||
};
|
||||
use std::{
|
||||
ffi::OsString,
|
||||
io::Write,
|
||||
sync::{Arc, OnceLock, atomic::AtomicBool},
|
||||
time::Duration,
|
||||
};
|
||||
use tokio::sync::{mpsc, watch};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
use windows_service::{
|
||||
define_windows_service,
|
||||
service::{ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus, ServiceType},
|
||||
service_control_handler::{self, ServiceControlHandlerResult, ServiceStatusHandle},
|
||||
service_dispatcher,
|
||||
};
|
||||
const NAME: &str = common::paths::SERVICE_NAME;
|
||||
static LOG_LEVEL: OnceLock<log::Level> = OnceLock::new();
|
||||
define_windows_service!(ffi_service_main, service_main);
|
||||
|
||||
pub(crate) fn dispatch(level: log::Level) -> anyhow::Result<()> {
|
||||
let _ = LOG_LEVEL.set(level);
|
||||
service_dispatcher::start(NAME, ffi_service_main).context("Start GP Connect through the Windows service manager")?;
|
||||
Ok(())
|
||||
}
|
||||
fn status(handle: &ServiceStatusHandle, state: ServiceState, failure: bool) -> windows_service::Result<()> {
|
||||
let running = state == ServiceState::Running;
|
||||
let pending = matches!(state, ServiceState::StartPending | ServiceState::StopPending);
|
||||
handle.set_service_status(ServiceStatus {
|
||||
service_type: ServiceType::OWN_PROCESS,
|
||||
current_state: state,
|
||||
controls_accepted: if running {
|
||||
ServiceControlAccept::STOP | ServiceControlAccept::SHUTDOWN
|
||||
} else {
|
||||
ServiceControlAccept::empty()
|
||||
},
|
||||
exit_code: if failure {
|
||||
ServiceExitCode::ServiceSpecific(1)
|
||||
} else {
|
||||
ServiceExitCode::Win32(0)
|
||||
},
|
||||
checkpoint: u32::from(pending),
|
||||
wait_hint: if pending {
|
||||
Duration::from_secs(30)
|
||||
} else {
|
||||
Duration::ZERO
|
||||
},
|
||||
process_id: None,
|
||||
})
|
||||
}
|
||||
fn service_main(_arguments: Vec<OsString>) {
|
||||
let stop = CancellationToken::new();
|
||||
let requested = stop.clone();
|
||||
let handle = match service_control_handler::register(NAME, move |control| match control {
|
||||
ServiceControl::Stop | ServiceControl::Shutdown => {
|
||||
requested.cancel();
|
||||
ServiceControlHandlerResult::NoError
|
||||
}
|
||||
ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
|
||||
_ => ServiceControlHandlerResult::NotImplemented,
|
||||
}) {
|
||||
Ok(handle) => handle,
|
||||
Err(_) => return,
|
||||
};
|
||||
let result = (|| -> anyhow::Result<()> {
|
||||
status(&handle, ServiceState::StartPending, false)?;
|
||||
ensure!(
|
||||
gpapi::windows::current_user_sid()? == "S-1-5-18",
|
||||
"GP Connect must run as LocalSystem"
|
||||
);
|
||||
let redaction = initialize_logger()?;
|
||||
log::info!("gpservice started: {}", crate::VERSION);
|
||||
crate::vpn_script::recover_network()?;
|
||||
let runtime = tokio::runtime::Builder::new_multi_thread().enable_all().build()?;
|
||||
runtime.block_on(run(&handle, stop, redaction))
|
||||
})();
|
||||
if let Err(error) = &result {
|
||||
log::error!("Windows service stopped: {error:#}");
|
||||
}
|
||||
let _ = status(&handle, ServiceState::Stopped, result.is_err());
|
||||
}
|
||||
fn initialize_logger() -> anyhow::Result<Arc<Redaction>> {
|
||||
let state = common::paths::service_lock_file();
|
||||
let directory = state.parent().context("Service state directory is unavailable")?;
|
||||
// The installer provisions these directories and their machine-wide ACLs.
|
||||
// Starting the daemon must not create a user-writable fallback location.
|
||||
ensure!(
|
||||
directory.is_dir() && common::paths::service_private_dir().is_dir(),
|
||||
"Install the GP Connect Windows service before starting it"
|
||||
);
|
||||
let writer = logging::writer(&directory.join("gpservice.log"))?;
|
||||
let redaction = Arc::new(Redaction::new());
|
||||
let filter = redaction.clone();
|
||||
let logger = env_logger::builder()
|
||||
.filter_level(log::LevelFilter::Trace)
|
||||
.target(env_logger::Target::Pipe(Box::new(writer)))
|
||||
.format(move |buffer, record| {
|
||||
writeln!(
|
||||
buffer,
|
||||
"[{} {:<5} {}] {}",
|
||||
buffer.timestamp(),
|
||||
record.level(),
|
||||
record.module_path().unwrap_or_default(),
|
||||
filter.redact_str(&record.args().to_string())
|
||||
)
|
||||
})
|
||||
.build();
|
||||
gpapi::logger::init_with_logger(*LOG_LEVEL.get().unwrap_or(&log::Level::Info), logger);
|
||||
Ok(redaction)
|
||||
}
|
||||
async fn run(handle: &ServiceStatusHandle, stop: CancellationToken, redaction: Arc<Redaction>) -> anyhow::Result<()> {
|
||||
let lock = Arc::new(LockFile::new(common::paths::service_lock_file(), std::process::id()));
|
||||
let registry = Arc::new(SessionRegistry::new(uuid::Uuid::new_v4()));
|
||||
let admission = admission::Admission::new(registry.clone())?;
|
||||
let (state, observed) = watch::channel(VpnState::Disconnected);
|
||||
let (mut vpn, lifecycle) = VpnTask::new(state, true, registry.clone());
|
||||
let dispatcher = Arc::new(RequestDispatcher::new(
|
||||
lifecycle,
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
redaction,
|
||||
false,
|
||||
true,
|
||||
));
|
||||
let websocket = WsServer::new(env!("CARGO_PKG_VERSION"), registry, dispatcher, observed, lock.clone());
|
||||
let service_cancel = websocket.cancel_token();
|
||||
let vpn_cancel = vpn.cancel_token();
|
||||
let (shutdown_tx, mut shutdown_rx) = mpsc::channel(4);
|
||||
let (ready_tx, ready_rx) = tokio::sync::oneshot::channel();
|
||||
let vpn_stop = service_cancel.clone();
|
||||
let vpn_handle = tokio::spawn(async move { vpn.start(vpn_stop).await });
|
||||
let websocket_shutdown = shutdown_tx.clone();
|
||||
let websocket_handle = tokio::spawn(async move { websocket.start(websocket_shutdown, ready_tx).await });
|
||||
ready_rx.await.context("Desktop protocol listener failed to start")?;
|
||||
let lease_cancel = service_cancel.clone();
|
||||
let admission_handle = tokio::spawn(async move {
|
||||
if let Err(error) = admission.run(lease_cancel).await {
|
||||
log::error!("Desktop admission stopped: {error:#}");
|
||||
let _ = shutdown_tx.send(()).await;
|
||||
}
|
||||
});
|
||||
status(handle, ServiceState::Running, false)?;
|
||||
tokio::select! { _ = stop.cancelled() => {}, _ = shutdown_rx.recv() => {} }
|
||||
let _ = status(handle, ServiceState::StopPending, false);
|
||||
vpn_cancel.cancel();
|
||||
service_cancel.cancel();
|
||||
let _ = tokio::join!(vpn_handle, websocket_handle, admission_handle);
|
||||
lock.unlock()?;
|
||||
log::info!("gpservice stopped");
|
||||
Ok(())
|
||||
}
|
||||
@@ -344,6 +344,7 @@ impl WsServer {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
pub fn context(&self) -> Arc<WsServerContext> {
|
||||
Arc::clone(&self.ctx)
|
||||
}
|
||||
|
||||
+16
-1
@@ -20,7 +20,6 @@ browser-launcher = { path = "../browser-launcher", default-features = false, fea
|
||||
tiny_http = { version = "0.12", optional = true }
|
||||
tempfile = { workspace = true, optional = true }
|
||||
uuid = { version = "1", optional = true, features = ["v4"] }
|
||||
uzers = { workspace = true, optional = true }
|
||||
|
||||
# Webview auth dependencies
|
||||
tauri = { workspace = true, optional = true }
|
||||
@@ -28,6 +27,7 @@ regex = { workspace = true, optional = true }
|
||||
tokio-util = { workspace = true, optional = true }
|
||||
html-escape = { version = "0.3", optional = true }
|
||||
url = { workspace = true, optional = true }
|
||||
serde_json = { workspace = true, optional = true }
|
||||
|
||||
[target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))'.dependencies]
|
||||
webkit2gtk = { version = "2", optional = true }
|
||||
@@ -60,6 +60,9 @@ webview-auth = [
|
||||
"dep:tokio-util",
|
||||
"dep:html-escape",
|
||||
"dep:url",
|
||||
"dep:serde_json",
|
||||
"dep:webview2-com",
|
||||
"dep:windows",
|
||||
"dep:gtk",
|
||||
"dep:webkit2gtk",
|
||||
"dep:block2",
|
||||
@@ -94,3 +97,15 @@ release-devtools = ["webview-auth", "tauri/devtools"]
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
uzers = { workspace = true, optional = true }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
# Child webviews let the Windows host own layout beside native controls.
|
||||
tauri = { workspace = true, optional = true, features = ["unstable"] }
|
||||
webview2-com = { version = "0.39", optional = true }
|
||||
windows = { version = "0.62", optional = true, features = ["Win32_Foundation", "Win32_Graphics_Gdi", "Win32_System_Com", "Win32_UI_Controls", "Win32_UI_HiDpi", "Win32_UI_Shell", "Win32_UI_WindowsAndMessaging"] }
|
||||
dunce = "1"
|
||||
winreg = "0.55"
|
||||
common = { path = "../common" }
|
||||
@@ -3,7 +3,6 @@ use std::{
|
||||
io::ErrorKind,
|
||||
os::unix::fs::{DirBuilderExt, FileTypeExt, MetadataExt, OpenOptionsExt, PermissionsExt},
|
||||
path::{Path, PathBuf},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
use anyhow::{Context, bail};
|
||||
@@ -14,16 +13,9 @@ use tokio::{
|
||||
time::timeout,
|
||||
};
|
||||
|
||||
const CALLBACK_SCHEME: &str = "globalprotectcallback";
|
||||
const PROTOCOL_MAGIC: &[u8; 4] = b"GPAC";
|
||||
const PROTOCOL_VERSION: u8 = 1;
|
||||
const MAX_CALLBACK_SIZE: usize = 1024 * 1024;
|
||||
const IO_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
|
||||
// Acceptance acknowledges delivery, including an authentication failure.
|
||||
const STATUS_ACCEPTED: u8 = 0;
|
||||
const STATUS_INVALID_CALLBACK: u8 = 1;
|
||||
const STATUS_UNSUPPORTED_VERSION: u8 = 2;
|
||||
mod protocol;
|
||||
pub use protocol::validate_auth_callback;
|
||||
use protocol::*;
|
||||
|
||||
#[cfg(target_os = "macos")]
|
||||
mod macos;
|
||||
@@ -232,62 +224,9 @@ fn remove_stale_socket(socket_path: &Path) -> anyhow::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn validate_auth_callback(callback: &str) -> anyhow::Result<()> {
|
||||
if callback.len() > MAX_CALLBACK_SIZE {
|
||||
bail!("Authentication callback exceeds the maximum supported size");
|
||||
}
|
||||
|
||||
let Some((scheme, data)) = callback.split_once(':') else {
|
||||
bail!("Authentication callback URL is invalid");
|
||||
};
|
||||
if scheme != CALLBACK_SCHEME || data.is_empty() {
|
||||
bail!("Authentication callback URL is invalid");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
enum CallbackReadError {
|
||||
UnsupportedVersion,
|
||||
Invalid,
|
||||
Io,
|
||||
}
|
||||
|
||||
async fn read_callback(stream: &mut UnixStream) -> Result<String, CallbackReadError> {
|
||||
let mut magic = [0_u8; 4];
|
||||
stream.read_exact(&mut magic).await.map_err(|_| CallbackReadError::Io)?;
|
||||
if &magic != PROTOCOL_MAGIC {
|
||||
return Err(CallbackReadError::Invalid);
|
||||
}
|
||||
|
||||
let version = stream.read_u8().await.map_err(|_| CallbackReadError::Io)?;
|
||||
if version != PROTOCOL_VERSION {
|
||||
return Err(CallbackReadError::UnsupportedVersion);
|
||||
}
|
||||
|
||||
let length = stream.read_u32().await.map_err(|_| CallbackReadError::Io)? as usize;
|
||||
if length == 0 || length > MAX_CALLBACK_SIZE {
|
||||
return Err(CallbackReadError::Invalid);
|
||||
}
|
||||
|
||||
let mut payload = vec![0; length];
|
||||
stream
|
||||
.read_exact(&mut payload)
|
||||
.await
|
||||
.map_err(|_| CallbackReadError::Io)?;
|
||||
let callback = String::from_utf8(payload).map_err(|_| CallbackReadError::Invalid)?;
|
||||
validate_auth_callback(&callback).map_err(|_| CallbackReadError::Invalid)?;
|
||||
Ok(callback)
|
||||
}
|
||||
|
||||
async fn write_response(stream: &mut UnixStream, status: u8) -> anyhow::Result<()> {
|
||||
stream.write_u8(PROTOCOL_VERSION).await?;
|
||||
stream.write_u8(status).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::time::Duration;
|
||||
use tempfile::tempdir;
|
||||
|
||||
use super::*;
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
//! Bounded authentication callback wire format, shared by local transports.
|
||||
use anyhow::bail;
|
||||
use std::time::Duration;
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
pub(super) const CALLBACK_SCHEME: &str = "globalprotectcallback";
|
||||
pub(super) const PROTOCOL_MAGIC: &[u8; 4] = b"GPAC";
|
||||
pub(super) const PROTOCOL_VERSION: u8 = 1;
|
||||
pub(super) const MAX_CALLBACK_SIZE: usize = 1024 * 1024;
|
||||
pub(super) const IO_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
|
||||
// Acceptance acknowledges delivery, including an authentication failure.
|
||||
pub(super) const STATUS_ACCEPTED: u8 = 0;
|
||||
pub(super) const STATUS_INVALID_CALLBACK: u8 = 1;
|
||||
pub(super) const STATUS_UNSUPPORTED_VERSION: u8 = 2;
|
||||
|
||||
pub fn validate_auth_callback(callback: &str) -> anyhow::Result<()> {
|
||||
if callback.len() > MAX_CALLBACK_SIZE {
|
||||
bail!("Authentication callback exceeds the maximum supported size");
|
||||
}
|
||||
|
||||
let Some((scheme, data)) = callback.split_once(':') else {
|
||||
bail!("Authentication callback URL is invalid");
|
||||
};
|
||||
if scheme != CALLBACK_SCHEME || data.is_empty() {
|
||||
bail!("Authentication callback URL is invalid");
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) enum CallbackReadError {
|
||||
UnsupportedVersion,
|
||||
Invalid,
|
||||
Io,
|
||||
}
|
||||
|
||||
pub(super) async fn read_callback(
|
||||
stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin),
|
||||
) -> Result<String, CallbackReadError> {
|
||||
let mut magic = [0_u8; 4];
|
||||
stream.read_exact(&mut magic).await.map_err(|_| CallbackReadError::Io)?;
|
||||
if &magic != PROTOCOL_MAGIC {
|
||||
return Err(CallbackReadError::Invalid);
|
||||
}
|
||||
|
||||
let version = stream.read_u8().await.map_err(|_| CallbackReadError::Io)?;
|
||||
if version != PROTOCOL_VERSION {
|
||||
return Err(CallbackReadError::UnsupportedVersion);
|
||||
}
|
||||
|
||||
let length = stream.read_u32().await.map_err(|_| CallbackReadError::Io)? as usize;
|
||||
if length == 0 || length > MAX_CALLBACK_SIZE {
|
||||
return Err(CallbackReadError::Invalid);
|
||||
}
|
||||
|
||||
let mut payload = vec![0; length];
|
||||
stream
|
||||
.read_exact(&mut payload)
|
||||
.await
|
||||
.map_err(|_| CallbackReadError::Io)?;
|
||||
let callback = String::from_utf8(payload).map_err(|_| CallbackReadError::Invalid)?;
|
||||
validate_auth_callback(&callback).map_err(|_| CallbackReadError::Invalid)?;
|
||||
Ok(callback)
|
||||
}
|
||||
|
||||
pub(super) async fn write_response(
|
||||
stream: &mut (impl tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin),
|
||||
status: u8,
|
||||
) -> anyhow::Result<()> {
|
||||
stream.write_u8(PROTOCOL_VERSION).await?;
|
||||
stream.write_u8(status).await?;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
//! Per-user Windows named pipe for browser authentication callbacks.
|
||||
use anyhow::{Context, bail};
|
||||
use gpapi::{auth::SamlAuthData, error::AuthDataParseError};
|
||||
use tokio::{
|
||||
io::{AsyncReadExt, AsyncWriteExt},
|
||||
net::windows::named_pipe::{ClientOptions, NamedPipeServer},
|
||||
time::timeout,
|
||||
};
|
||||
#[path = "protocol.rs"]
|
||||
mod protocol;
|
||||
pub use protocol::validate_auth_callback;
|
||||
use protocol::*;
|
||||
|
||||
pub struct AuthCallbackReceiver {
|
||||
listener: NamedPipeServer,
|
||||
}
|
||||
impl AuthCallbackReceiver {
|
||||
pub fn bind() -> anyhow::Result<Self> {
|
||||
Ok(Self {
|
||||
listener: gpapi::windows::create_user_pipe(&pipe_name()?, true)
|
||||
.context("Another browser authentication is already waiting")?,
|
||||
})
|
||||
}
|
||||
pub async fn receive(mut self) -> anyhow::Result<SamlAuthData> {
|
||||
loop {
|
||||
self.listener.connect().await?;
|
||||
let mut stream = &mut self.listener;
|
||||
let callback = timeout(IO_TIMEOUT, read_callback(&mut stream)).await;
|
||||
let result = match callback {
|
||||
Ok(Ok(callback)) => match SamlAuthData::from_gpcallback(&callback) {
|
||||
Ok(data) => {
|
||||
let _ = write_response(&mut stream, STATUS_ACCEPTED).await;
|
||||
Some(Ok(data))
|
||||
}
|
||||
Err(error @ AuthDataParseError::AuthenticationFailed(_)) => {
|
||||
let _ = write_response(&mut stream, STATUS_ACCEPTED).await;
|
||||
Some(Err(error.into()))
|
||||
}
|
||||
Err(_) => {
|
||||
let _ = write_response(&mut stream, STATUS_INVALID_CALLBACK).await;
|
||||
None
|
||||
}
|
||||
},
|
||||
Ok(Err(CallbackReadError::UnsupportedVersion)) => {
|
||||
let _ = write_response(&mut stream, STATUS_UNSUPPORTED_VERSION).await;
|
||||
None
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
// DisconnectNamedPipe discards unread response bytes. Wait for the client
|
||||
// to confirm it consumed the response before disconnecting this instance.
|
||||
let _ = timeout(IO_TIMEOUT, stream.read_u8()).await;
|
||||
self.listener.disconnect()?;
|
||||
if let Some(result) = result {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
fn pipe_name() -> anyhow::Result<String> {
|
||||
Ok(format!(
|
||||
r"\\.\pipe\GPConnect.Auth.{}",
|
||||
gpapi::windows::current_user_sid()?
|
||||
))
|
||||
}
|
||||
|
||||
pub async fn forward_auth_callback(callback: &str) -> anyhow::Result<()> {
|
||||
validate_auth_callback(callback)?;
|
||||
timeout(IO_TIMEOUT, async {
|
||||
let mut stream = ClientOptions::new()
|
||||
.open(pipe_name()?)
|
||||
.context("No external-browser authentication is waiting for a callback")?;
|
||||
stream.write_all(PROTOCOL_MAGIC).await?;
|
||||
stream.write_u8(PROTOCOL_VERSION).await?;
|
||||
stream.write_u32(callback.len() as u32).await?;
|
||||
stream.write_all(callback.as_bytes()).await?;
|
||||
let version = stream.read_u8().await?;
|
||||
let status = stream.read_u8().await?;
|
||||
stream.write_u8(status).await?;
|
||||
anyhow::ensure!(
|
||||
version == PROTOCOL_VERSION,
|
||||
"Authentication callback protocol version mismatch"
|
||||
);
|
||||
match status {
|
||||
STATUS_ACCEPTED => Ok(()),
|
||||
STATUS_INVALID_CALLBACK => bail!("Authentication callback was rejected"),
|
||||
_ => bail!("Authentication callback protocol is unsupported"),
|
||||
}
|
||||
})
|
||||
.await
|
||||
.context("Timed out forwarding the authentication callback")?
|
||||
}
|
||||
|
||||
pub fn ensure_auth_callback_handler() -> anyhow::Result<()> {
|
||||
use winreg::{RegKey, enums::HKEY_CURRENT_USER};
|
||||
let executable = common::binary_paths::gpauth();
|
||||
anyhow::ensure!(executable.is_file(), "The authentication helper is missing");
|
||||
let root = RegKey::predef(HKEY_CURRENT_USER);
|
||||
let (scheme, _) = root.create_subkey(r"Software\Classes\globalprotectcallback")?;
|
||||
scheme.set_value("", &"URL:GlobalProtect authentication callback")?;
|
||||
scheme.set_value("URL Protocol", &"")?;
|
||||
let (command, _) = scheme.create_subkey(r"shell\open\command")?;
|
||||
// URL association activation requires a shell path, not Rust's verbatim
|
||||
// canonical path (\\?\C:\...), even though CreateProcess accepts both.
|
||||
let executable = dunce::simplified(&executable);
|
||||
command.set_value("", &format!("\"{}\" auth-callback \"%1\"", executable.display()))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[tokio::test]
|
||||
async fn forwards_browser_callback_over_private_windows_pipe() {
|
||||
let receiver = AuthCallbackReceiver::bind().unwrap();
|
||||
// The first-instance flag preserves one pending browser authentication per user.
|
||||
assert!(AuthCallbackReceiver::bind().is_err());
|
||||
let sender = tokio::spawn(async {
|
||||
forward_auth_callback("globalprotectcallback:cas-as=1&[email protected]&token=test-token").await
|
||||
});
|
||||
let data = timeout(std::time::Duration::from_secs(5), receiver.receive())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
sender.await.unwrap().unwrap();
|
||||
assert_eq!(data.username(), "[email protected]");
|
||||
assert_eq!(data.token(), Some("test-token"));
|
||||
}
|
||||
}
|
||||
@@ -8,6 +8,7 @@ use gpapi::{
|
||||
mod browser;
|
||||
|
||||
#[cfg(feature = "browser-auth")]
|
||||
#[cfg_attr(windows, path = "callback/windows.rs")]
|
||||
mod callback;
|
||||
|
||||
#[cfg(feature = "browser-auth")]
|
||||
|
||||
@@ -12,12 +12,17 @@ mod platform_impl;
|
||||
#[path = "webview/macos.rs"]
|
||||
mod platform_impl;
|
||||
|
||||
#[cfg(windows)]
|
||||
#[path = "webview/windows.rs"]
|
||||
mod platform_impl;
|
||||
|
||||
#[cfg(not(any(
|
||||
windows,
|
||||
target_os = "macos",
|
||||
target_os = "linux",
|
||||
target_os = "freebsd",
|
||||
target_os = "openbsd"
|
||||
)))]
|
||||
compile_error!("webview-auth is only supported on macOS and GTK/WebKitGTK Unix targets");
|
||||
compile_error!("webview-auth is only supported on Windows, macOS and GTK/WebKitGTK Unix targets");
|
||||
|
||||
pub use webview_auth::{WebviewAuthenticator, apply_auth_theme};
|
||||
@@ -9,7 +9,7 @@ use tokio_util::sync::CancellationToken;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) enum AuthDataLocation {
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
Headers,
|
||||
Body,
|
||||
}
|
||||
@@ -155,7 +155,7 @@ impl AuthMessenger {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
pub fn read_from_response(&self, auth_response: &impl super::webview_auth::GetHeader, generation: u64) {
|
||||
use log::warn;
|
||||
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
use std::{future::Future, pin::Pin, sync::Arc, time::Duration};
|
||||
|
||||
use anyhow::bail;
|
||||
#[cfg(not(windows))]
|
||||
use gpapi::utils::window::get_title_bar_height;
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
use gpapi::utils::window::{WindowTypeHint, set_window_type_hint};
|
||||
use gpapi::{
|
||||
@@ -8,24 +10,51 @@ use gpapi::{
|
||||
error::ServerTlsError,
|
||||
gp_params::GpParams,
|
||||
os_profile::{WebviewUserAgent, WebviewUserAgentTransform},
|
||||
utils::{redact::redact_uri, window::get_title_bar_height},
|
||||
utils::redact::redact_uri,
|
||||
};
|
||||
use log::{info, warn};
|
||||
#[cfg(target_os = "macos")]
|
||||
use tauri::Manager;
|
||||
use tauri::{AppHandle, WebviewUrl, WebviewWindow, WindowEvent};
|
||||
#[cfg(not(windows))]
|
||||
use tauri::WebviewUrl;
|
||||
use tauri::{AppHandle, WindowEvent};
|
||||
use tokio::{sync::oneshot, time};
|
||||
|
||||
use crate::auth_prelogin;
|
||||
|
||||
#[cfg(not(windows))]
|
||||
use super::address_bar::TOOLBAR_HEIGHT;
|
||||
use super::auth_messenger::{AuthError, AuthEvent, AuthMessenger};
|
||||
use super::recovery::{Recovery, RecoveryStatus, RetryPlan, RetrySource, RetryTiming};
|
||||
|
||||
#[cfg(not(windows))]
|
||||
type AuthWindow = tauri::WebviewWindow;
|
||||
#[cfg(windows)]
|
||||
use super::platform_impl::{AuthWindow, create_auth_window};
|
||||
|
||||
#[cfg(not(windows))]
|
||||
fn create_auth_window(app: &AppHandle, title: &str, theme: Option<tauri::Theme>) -> anyhow::Result<AuthWindow> {
|
||||
let builder = AuthWindow::builder(app, "auth_window", WebviewUrl::default())
|
||||
.title(title)
|
||||
.theme(theme)
|
||||
.devtools(cfg!(any(debug_assertions, feature = "release-devtools")));
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
let builder = builder.on_navigation(super::platform_impl::open_okta_verify);
|
||||
Ok(
|
||||
builder
|
||||
.inner_size(900.0, 650.0 + get_title_bar_height() + TOOLBAR_HEIGHT)
|
||||
.min_inner_size(400.0, 300.0)
|
||||
.focused(true)
|
||||
.visible(false)
|
||||
.center()
|
||||
.build()?,
|
||||
)
|
||||
}
|
||||
|
||||
const RESTART_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
|
||||
pub trait PlatformWebviewExt {
|
||||
fn install_auth_controls(&self, window: &WebviewWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()>;
|
||||
pub(super) trait PlatformWebviewExt {
|
||||
fn install_auth_controls(&self, window: &AuthWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()>;
|
||||
|
||||
fn set_recovery_status(&self, status: RecoveryStatus) -> anyhow::Result<()>;
|
||||
|
||||
@@ -54,7 +83,7 @@ pub trait PlatformWebviewExt {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(windows, target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
pub trait GetHeader {
|
||||
fn get_header(&self, key: &str) -> Option<String>;
|
||||
}
|
||||
@@ -125,19 +154,7 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
|
||||
pub async fn authenticate(&self, app_handle: &AppHandle) -> anyhow::Result<SamlAuthData> {
|
||||
let auth_messenger = Arc::new(AuthMessenger::new());
|
||||
let auth_window_builder = WebviewWindow::builder(app_handle, "auth_window", WebviewUrl::default())
|
||||
.title(self.window_title)
|
||||
.theme(native_theme(self.window_theme))
|
||||
.devtools(cfg!(any(debug_assertions, feature = "release-devtools")));
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
let auth_window_builder = auth_window_builder.on_navigation(super::platform_impl::open_okta_verify);
|
||||
let auth_window = auth_window_builder
|
||||
.inner_size(900.0, 650.0 + get_title_bar_height() + TOOLBAR_HEIGHT)
|
||||
.min_inner_size(400.0, 300.0)
|
||||
.focused(true)
|
||||
.visible(false)
|
||||
.center()
|
||||
.build()?;
|
||||
let auth_window = create_auth_window(app_handle, self.window_title, native_theme(self.window_theme))?;
|
||||
|
||||
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
|
||||
set_window_type_hint(&auth_window, WindowTypeHint::Dialog)?;
|
||||
@@ -170,7 +187,7 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
|
||||
async fn wait_for_auth(
|
||||
&self,
|
||||
auth_window: &WebviewWindow,
|
||||
auth_window: &AuthWindow,
|
||||
auth_messenger: Arc<AuthMessenger>,
|
||||
) -> anyhow::Result<SamlAuthData> {
|
||||
let mut recovery = Recovery::default();
|
||||
@@ -310,13 +327,16 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
|
||||
async fn setup_auth_window(
|
||||
&self,
|
||||
auth_window: &WebviewWindow,
|
||||
auth_window: &AuthWindow,
|
||||
auth_messenger: Arc<AuthMessenger>,
|
||||
) -> anyhow::Result<()> {
|
||||
info!("Setting up auth window...");
|
||||
|
||||
if self.clean {
|
||||
info!("Clearing all browsing data...");
|
||||
#[cfg(windows)]
|
||||
super::platform_impl::clear_browsing_data(auth_window).await?;
|
||||
#[cfg(not(windows))]
|
||||
auth_window.clear_all_browsing_data()?;
|
||||
}
|
||||
|
||||
@@ -361,7 +381,7 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn handle_not_found(&self, auth_window: &WebviewWindow, auth_messenger: &Arc<AuthMessenger>) {
|
||||
fn handle_not_found(&self, auth_window: &AuthWindow, auth_messenger: &Arc<AuthMessenger>) {
|
||||
let visible = auth_window.is_visible().unwrap_or(false);
|
||||
if visible {
|
||||
return;
|
||||
@@ -370,7 +390,7 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
auth_messenger.schedule_raise_window(2);
|
||||
}
|
||||
|
||||
fn update_recovery(&self, auth_window: &WebviewWindow, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
fn update_recovery(&self, auth_window: &AuthWindow, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
if status != RecoveryStatus::Hidden {
|
||||
self.raise_window(auth_window);
|
||||
}
|
||||
@@ -397,7 +417,7 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
|
||||
fn load_restarted_sign_in(
|
||||
&self,
|
||||
auth_window: &WebviewWindow,
|
||||
auth_window: &AuthWindow,
|
||||
messenger: &Arc<AuthMessenger>,
|
||||
auth_request: String,
|
||||
) -> anyhow::Result<()> {
|
||||
@@ -415,7 +435,7 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn raise_window(&self, auth_window: &WebviewWindow) {
|
||||
fn raise_window(&self, auth_window: &AuthWindow) {
|
||||
let visible = auth_window.is_visible().unwrap_or(false);
|
||||
if visible {
|
||||
return;
|
||||
|
||||
@@ -0,0 +1,380 @@
|
||||
//! WebView2 authentication. All COM objects and native controls stay on the UI thread.
|
||||
use std::{
|
||||
cell::{Cell, RefCell},
|
||||
collections::HashMap,
|
||||
rc::Rc,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use super::{
|
||||
auth_messenger::{AuthDataLocation, AuthError, AuthEvent, AuthMessenger},
|
||||
recovery::RecoveryStatus,
|
||||
webview_auth::{GetHeader, PlatformWebviewExt},
|
||||
};
|
||||
use anyhow::{Context, bail};
|
||||
use gpapi::auth::SamlAuthData;
|
||||
use tauri::{
|
||||
AppHandle, LogicalPosition, Webview, WebviewBuilder, WebviewUrl, Window, WindowBuilder, webview::PlatformWebview,
|
||||
};
|
||||
use webview2_com::{
|
||||
ClearBrowsingDataCompletedHandler, CoTaskMemPWSTR, DOMContentLoadedEventHandler, ExecuteScriptCompletedHandler,
|
||||
Microsoft::Web::WebView2::Win32::*, NavigationCompletedEventHandler, NavigationStartingEventHandler,
|
||||
SourceChangedEventHandler, WebResourceResponseReceivedEventHandler,
|
||||
};
|
||||
use windows::core::{BOOL, HSTRING, Interface, PWSTR};
|
||||
|
||||
#[path = "windows/controls.rs"]
|
||||
mod controls;
|
||||
#[path = "windows/tls.rs"]
|
||||
mod tls;
|
||||
|
||||
/// Windows hosts native chrome and a manually sized child webview in one window.
|
||||
/// Host-owned child bounds keep the page surface below the native controls
|
||||
/// throughout live resizing.
|
||||
#[derive(Clone)]
|
||||
pub(super) struct AuthWindow {
|
||||
window: Window,
|
||||
webview: Webview,
|
||||
}
|
||||
|
||||
impl std::ops::Deref for AuthWindow {
|
||||
type Target = Window;
|
||||
fn deref(&self) -> &Window {
|
||||
&self.window
|
||||
}
|
||||
}
|
||||
|
||||
impl AuthWindow {
|
||||
pub(super) fn with_webview(&self, callback: impl FnOnce(PlatformWebview) + Send + 'static) -> tauri::Result<()> {
|
||||
self.webview.with_webview(callback)
|
||||
}
|
||||
}
|
||||
|
||||
impl gpapi::utils::window::WindowExt for AuthWindow {
|
||||
fn raise(&self) -> anyhow::Result<()> {
|
||||
self.window.show()?;
|
||||
self.window.set_focus()?;
|
||||
self.webview.set_focus()?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn create_auth_window(
|
||||
app: &AppHandle,
|
||||
title: &str,
|
||||
theme: Option<tauri::Theme>,
|
||||
) -> anyhow::Result<AuthWindow> {
|
||||
let window = WindowBuilder::new(app, "auth_window")
|
||||
.title(title)
|
||||
.theme(theme)
|
||||
.inner_size(900.0, 650.0 + super::address_bar::TOOLBAR_HEIGHT)
|
||||
.min_inner_size(400.0, 300.0)
|
||||
.focused(true)
|
||||
.visible(false)
|
||||
.center()
|
||||
.build()?;
|
||||
let webview = window.add_child(
|
||||
WebviewBuilder::new("auth_webview", WebviewUrl::default())
|
||||
.devtools(cfg!(any(debug_assertions, feature = "release-devtools"))),
|
||||
LogicalPosition::new(0.0, 0.0),
|
||||
window.inner_size()?,
|
||||
)?;
|
||||
Ok(AuthWindow { window, webview })
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
static STATES: RefCell<HashMap<usize, Rc<State>>> = RefCell::default();
|
||||
}
|
||||
|
||||
struct State {
|
||||
core: ICoreWebView2,
|
||||
controller: ICoreWebView2Controller,
|
||||
messenger: Arc<AuthMessenger>,
|
||||
controls: controls::Controls,
|
||||
pending: Cell<Option<u64>>,
|
||||
navigations: RefCell<HashMap<u64, u64>>,
|
||||
document: RefCell<(String, u64)>,
|
||||
tls: RefCell<tls::Policy>,
|
||||
}
|
||||
|
||||
fn text(get: impl FnOnce(*mut PWSTR) -> windows::core::Result<()>) -> windows::core::Result<String> {
|
||||
let mut value = PWSTR::null();
|
||||
let result = get(&mut value);
|
||||
let value = CoTaskMemPWSTR::from(value);
|
||||
result?;
|
||||
Ok(value.to_string())
|
||||
}
|
||||
|
||||
fn state(webview: &PlatformWebview) -> anyhow::Result<Rc<State>> {
|
||||
let core = unsafe { webview.controller().CoreWebView2()? };
|
||||
STATES
|
||||
.with_borrow(|states| states.get(&(core.as_raw() as usize)).cloned())
|
||||
.context("Authentication controls are unavailable")
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn read_html(&self, generation: u64) -> windows::core::Result<()> {
|
||||
if generation != self.messenger.generation() {
|
||||
return Ok(());
|
||||
}
|
||||
let messenger = Arc::clone(&self.messenger);
|
||||
unsafe {
|
||||
self.core.ExecuteScript(
|
||||
&HSTRING::from("document.documentElement.outerHTML"),
|
||||
&ExecuteScriptCompletedHandler::create(Box::new(move |result, json| {
|
||||
result?;
|
||||
if let Ok(html) = serde_json::from_str::<String>(&json) {
|
||||
messenger.read_from_html(&html, generation);
|
||||
}
|
||||
Ok(())
|
||||
})),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fn listen(self: &Rc<Self>) -> windows::core::Result<()> {
|
||||
let mut token = 0;
|
||||
let weak = Rc::downgrade(self);
|
||||
let starting = NavigationStartingEventHandler::create(Box::new(move |_, args| {
|
||||
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
|
||||
return Ok(());
|
||||
};
|
||||
unsafe {
|
||||
let mut id = 0;
|
||||
args.NavigationId(&mut id)?;
|
||||
let generation = *state
|
||||
.navigations
|
||||
.borrow_mut()
|
||||
.entry(id)
|
||||
.or_insert_with(|| state.pending.take().unwrap_or_else(|| state.messenger.generation()));
|
||||
let uri = text(|p| args.Uri(p))?;
|
||||
if uri.starts_with("globalprotectcallback:") {
|
||||
args.SetCancel(true)?;
|
||||
match SamlAuthData::from_gpcallback(&uri) {
|
||||
Ok(data) => state
|
||||
.messenger
|
||||
.send_auth_event(AuthEvent::Data(generation, data, AuthDataLocation::Body)),
|
||||
Err(error) => state
|
||||
.messenger
|
||||
.send_auth_event(AuthEvent::Error(generation, AuthError::invalid_from_body(error.into()))),
|
||||
}
|
||||
} else if generation == state.messenger.generation() {
|
||||
*state.document.borrow_mut() = (uri, generation);
|
||||
state.messenger.cancel_raise_window();
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
unsafe {
|
||||
self.core.add_NavigationStarting(&starting, &mut token)?;
|
||||
}
|
||||
|
||||
let weak = Rc::downgrade(self);
|
||||
let loaded = DOMContentLoadedEventHandler::create(Box::new(move |_, args| {
|
||||
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
|
||||
return Ok(());
|
||||
};
|
||||
let mut id = 0;
|
||||
unsafe {
|
||||
args.NavigationId(&mut id)?;
|
||||
}
|
||||
let generation = state.navigations.borrow().get(&id).copied();
|
||||
if let Some(generation) = generation {
|
||||
state.read_html(generation)?;
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
unsafe {
|
||||
self
|
||||
.core
|
||||
.cast::<ICoreWebView2_2>()?
|
||||
.add_DOMContentLoaded(&loaded, &mut token)?;
|
||||
}
|
||||
|
||||
let weak = Rc::downgrade(self);
|
||||
let completed = NavigationCompletedEventHandler::create(Box::new(move |_, args| {
|
||||
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
|
||||
return Ok(());
|
||||
};
|
||||
unsafe {
|
||||
let mut id = 0;
|
||||
args.NavigationId(&mut id)?;
|
||||
let Some(generation) = state.navigations.borrow_mut().remove(&id) else {
|
||||
return Ok(());
|
||||
};
|
||||
let mut success = BOOL(0);
|
||||
args.IsSuccess(&mut success)?;
|
||||
if success.as_bool() {
|
||||
state.read_html(generation)?;
|
||||
state.messenger.send_auth_event(AuthEvent::PageLoaded(generation));
|
||||
} else {
|
||||
let mut error = COREWEBVIEW2_WEB_ERROR_STATUS_UNKNOWN;
|
||||
args.WebErrorStatus(&mut error)?;
|
||||
if error != COREWEBVIEW2_WEB_ERROR_STATUS_OPERATION_CANCELED {
|
||||
state.messenger.send_auth_event(AuthEvent::Error(
|
||||
generation,
|
||||
AuthError::LoadFailed(anyhow::anyhow!("WebView2 navigation failed ({})", error.0)),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
unsafe {
|
||||
self.core.add_NavigationCompleted(&completed, &mut token)?;
|
||||
}
|
||||
|
||||
let weak = Rc::downgrade(self);
|
||||
let source = SourceChangedEventHandler::create(Box::new(move |_, _| {
|
||||
if let Some(state) = weak.upgrade() {
|
||||
let uri = unsafe { text(|p| state.core.Source(p))? };
|
||||
state.controls.set_address(&uri)?;
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
unsafe {
|
||||
self.core.add_SourceChanged(&source, &mut token)?;
|
||||
}
|
||||
|
||||
let weak = Rc::downgrade(self);
|
||||
let response = WebResourceResponseReceivedEventHandler::create(Box::new(move |_, args| {
|
||||
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
|
||||
return Ok(());
|
||||
};
|
||||
unsafe {
|
||||
let uri = text(|p| args.Request()?.Uri(p))?;
|
||||
let (document, generation) = state.document.borrow().clone();
|
||||
// Subresources must not supply authentication credentials for the page.
|
||||
if uri == document && generation == state.messenger.generation() {
|
||||
state
|
||||
.messenger
|
||||
.read_from_response(&Headers(args.Response()?.Headers()?), generation);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
unsafe {
|
||||
self
|
||||
.core
|
||||
.cast::<ICoreWebView2_2>()?
|
||||
.add_WebResourceResponseReceived(&response, &mut token)?;
|
||||
}
|
||||
tls::install(self)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
struct Headers(ICoreWebView2HttpResponseHeaders);
|
||||
impl GetHeader for Headers {
|
||||
fn get_header(&self, key: &str) -> Option<String> {
|
||||
unsafe { text(|p| self.0.GetHeader(&HSTRING::from(key), p)).ok() }
|
||||
}
|
||||
}
|
||||
|
||||
impl PlatformWebviewExt for PlatformWebview {
|
||||
fn install_auth_controls(&self, window: &AuthWindow, messenger: Arc<AuthMessenger>) -> anyhow::Result<()> {
|
||||
let controller = self.controller();
|
||||
let core = unsafe { controller.CoreWebView2()? };
|
||||
let key = core.as_raw() as usize;
|
||||
let controls = controls::Controls::new(window, &controller, key)?;
|
||||
let state = Rc::new(State {
|
||||
core,
|
||||
controller,
|
||||
messenger,
|
||||
controls,
|
||||
pending: Cell::new(None),
|
||||
navigations: RefCell::default(),
|
||||
document: RefCell::new((String::new(), 0)),
|
||||
tls: RefCell::default(),
|
||||
});
|
||||
STATES.with_borrow_mut(|states| states.insert(key, Rc::clone(&state)));
|
||||
state.listen()?;
|
||||
state.controls.layout(&state)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_recovery_status(&self, status: RecoveryStatus) -> anyhow::Result<()> {
|
||||
let state = state(self)?;
|
||||
state.controls.update(&state, status)?;
|
||||
Ok(())
|
||||
}
|
||||
fn stop_loading(&self) {
|
||||
let _ = unsafe { self.controller().CoreWebView2().and_then(|wv| wv.Stop()) };
|
||||
}
|
||||
fn confirm_tls_exception(&self) -> anyhow::Result<()> {
|
||||
tls::confirm(state(self)?.as_ref())
|
||||
}
|
||||
fn ignore_tls_errors(&self) -> anyhow::Result<()> {
|
||||
state(self)?.tls.borrow_mut().ignore_errors = true;
|
||||
Ok(())
|
||||
}
|
||||
fn user_agent(&self) -> anyhow::Result<String> {
|
||||
unsafe {
|
||||
Ok(text(|p| {
|
||||
self
|
||||
.controller()
|
||||
.CoreWebView2()?
|
||||
.Settings()?
|
||||
.cast::<ICoreWebView2Settings2>()?
|
||||
.UserAgent(p)
|
||||
})?)
|
||||
}
|
||||
}
|
||||
fn set_user_agent(&self, user_agent: &str) -> anyhow::Result<()> {
|
||||
unsafe {
|
||||
self
|
||||
.controller()
|
||||
.CoreWebView2()?
|
||||
.Settings()?
|
||||
.cast::<ICoreWebView2Settings2>()?
|
||||
.SetUserAgent(&HSTRING::from(user_agent))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn load_url(&self, url: &str) -> anyhow::Result<()> {
|
||||
let state = state(self)?;
|
||||
state.pending.set(Some(state.messenger.generation()));
|
||||
unsafe {
|
||||
state.core.Navigate(&HSTRING::from(url))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn load_html(&self, html: &str) -> anyhow::Result<()> {
|
||||
let state = state(self)?;
|
||||
state.pending.set(Some(state.messenger.generation()));
|
||||
unsafe {
|
||||
state.core.NavigateToString(&HSTRING::from(html))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// WebView2 clears profiles asynchronously; do not navigate until cookies are gone.
|
||||
pub(super) async fn clear_browsing_data(window: &AuthWindow) -> anyhow::Result<()> {
|
||||
let (tx, rx) = tokio::sync::oneshot::channel();
|
||||
window.with_webview(move |wv| {
|
||||
let tx = Rc::new(RefCell::new(Some(tx)));
|
||||
let complete = Rc::clone(&tx);
|
||||
let callback = ClearBrowsingDataCompletedHandler::create(Box::new(move |result| {
|
||||
if let Some(tx) = complete.borrow_mut().take() {
|
||||
let _ = tx.send(result);
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
let result = (|| unsafe {
|
||||
wv.controller()
|
||||
.CoreWebView2()?
|
||||
.cast::<ICoreWebView2_13>()?
|
||||
.Profile()?
|
||||
.cast::<ICoreWebView2Profile2>()?
|
||||
.ClearBrowsingDataAll(&callback)
|
||||
})();
|
||||
if let Err(error) = result {
|
||||
if let Some(tx) = tx.borrow_mut().take() {
|
||||
let _ = tx.send(Err(error));
|
||||
}
|
||||
}
|
||||
})?;
|
||||
rx.await.context("Could not clear sign-in data")??;
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,334 @@
|
||||
//! Native controls remain outside the identity provider's document.
|
||||
use super::*;
|
||||
use windows::{
|
||||
Win32::{
|
||||
Foundation::{COLORREF, HWND, LPARAM, LRESULT, RECT, WPARAM},
|
||||
Graphics::Gdi::*,
|
||||
UI::{
|
||||
Controls::EM_SETRECT,
|
||||
HiDpi::{GetDpiForWindow, SystemParametersInfoForDpi},
|
||||
Shell::{DefSubclassProc, RemoveWindowSubclass, SetWindowSubclass},
|
||||
WindowsAndMessaging::*,
|
||||
},
|
||||
},
|
||||
core::{PCWSTR, w},
|
||||
};
|
||||
|
||||
const SUBCLASS: usize = 0x47504155;
|
||||
const ADDRESS_SUBCLASS: usize = 0x47504156;
|
||||
const ADDRESS_HEIGHT: i32 = 24;
|
||||
const TOOLBAR_HEIGHT: i32 = 34;
|
||||
const RETRY: usize = 101;
|
||||
const PROCEED: usize = 102;
|
||||
const CANCEL: usize = 103;
|
||||
|
||||
pub(super) struct Controls {
|
||||
pub(super) parent: HWND,
|
||||
webview_host: HWND,
|
||||
address: HWND,
|
||||
message: HWND,
|
||||
retry: HWND,
|
||||
proceed: HWND,
|
||||
cancel: HWND,
|
||||
status: Cell<RecoveryStatus>,
|
||||
font: Cell<Option<(u32, HFONT)>>,
|
||||
}
|
||||
|
||||
impl Controls {
|
||||
pub(super) fn new(window: &AuthWindow, controller: &ICoreWebView2Controller, key: usize) -> anyhow::Result<Self> {
|
||||
// The host owns both the toolbar and the child webview's remaining area.
|
||||
let parent = HWND(window.hwnd()?.0);
|
||||
let mut webview_host = HWND::default();
|
||||
unsafe {
|
||||
controller.ParentWindow(&mut webview_host)?;
|
||||
}
|
||||
let child = |class: PCWSTR, title: &str, style: WINDOW_STYLE, id: usize| -> windows::core::Result<HWND> {
|
||||
unsafe {
|
||||
let hwnd = CreateWindowExW(
|
||||
WINDOW_EX_STYLE::default(),
|
||||
class,
|
||||
&HSTRING::from(title),
|
||||
WS_CHILD | style,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
Some(parent),
|
||||
Some(HMENU(id as *mut _)),
|
||||
None,
|
||||
None,
|
||||
)?;
|
||||
Ok(hwnd)
|
||||
}
|
||||
};
|
||||
let controls = Self {
|
||||
parent,
|
||||
webview_host,
|
||||
address: child(
|
||||
w!("EDIT"),
|
||||
super::super::address_bar::LOADING_ADDRESS,
|
||||
WS_VISIBLE | WS_BORDER | WINDOW_STYLE(ES_READONLY as u32 | ES_MULTILINE as u32 | ES_AUTOHSCROLL as u32),
|
||||
0,
|
||||
)?,
|
||||
message: child(w!("STATIC"), "", WINDOW_STYLE::default(), 0)?,
|
||||
retry: child(w!("BUTTON"), "Try Again", WS_TABSTOP, RETRY)?,
|
||||
proceed: child(w!("BUTTON"), "Continue Anyway…", WS_TABSTOP, PROCEED)?,
|
||||
cancel: child(w!("BUTTON"), "Cancel", WS_TABSTOP, CANCEL)?,
|
||||
status: Cell::new(RecoveryStatus::Hidden),
|
||||
font: Cell::new(None),
|
||||
};
|
||||
unsafe {
|
||||
anyhow::ensure!(
|
||||
SetWindowSubclass(controls.address, Some(address_proc), ADDRESS_SUBCLASS, 0).as_bool(),
|
||||
"Could not style the sign-in address"
|
||||
);
|
||||
anyhow::ensure!(
|
||||
SetWindowSubclass(parent, Some(window_proc), SUBCLASS, key).as_bool(),
|
||||
"Could not install sign-in controls"
|
||||
);
|
||||
}
|
||||
Ok(controls)
|
||||
}
|
||||
|
||||
pub(super) fn set_address(&self, uri: &str) -> windows::core::Result<()> {
|
||||
unsafe {
|
||||
SetWindowTextW(
|
||||
self.address,
|
||||
&HSTRING::from(super::super::address_bar::display_address(Some(uri))),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn update(&self, state: &State, status: RecoveryStatus) -> windows::core::Result<()> {
|
||||
self.status.set(status);
|
||||
let message = if status.detail().is_empty() {
|
||||
status.message().to_owned()
|
||||
} else {
|
||||
format!("{}\r\n{}", status.message(), status.detail())
|
||||
};
|
||||
unsafe {
|
||||
SetWindowTextW(self.message, &HSTRING::from(message))?;
|
||||
for (hwnd, visible) in [
|
||||
(self.message, status != RecoveryStatus::Hidden),
|
||||
(self.retry, status.can_retry()),
|
||||
(self.proceed, status.can_continue()),
|
||||
(self.cancel, status.blocks_page()),
|
||||
] {
|
||||
let _ = ShowWindow(hwnd, if visible { SW_SHOW } else { SW_HIDE });
|
||||
}
|
||||
state.controller.SetIsVisible(!status.blocks_page())?;
|
||||
}
|
||||
self.layout(state)
|
||||
}
|
||||
|
||||
pub(super) fn layout(&self, state: &State) -> windows::core::Result<()> {
|
||||
unsafe {
|
||||
let dpi = GetDpiForWindow(self.parent);
|
||||
let scale = dpi as f64 / 96.0;
|
||||
let px = |value: i32| (value as f64 * scale).round() as i32;
|
||||
let mut bounds = RECT::default();
|
||||
GetClientRect(self.parent, &mut bounds)?;
|
||||
let width = bounds.right;
|
||||
if self.font.get().is_none_or(|(current_dpi, _)| current_dpi != dpi) {
|
||||
let mut metrics = NONCLIENTMETRICSW {
|
||||
cbSize: std::mem::size_of::<NONCLIENTMETRICSW>() as u32,
|
||||
..Default::default()
|
||||
};
|
||||
SystemParametersInfoForDpi(
|
||||
SPI_GETNONCLIENTMETRICS.0,
|
||||
metrics.cbSize,
|
||||
Some(&mut metrics as *mut _ as *mut _),
|
||||
0,
|
||||
dpi,
|
||||
)?;
|
||||
metrics.lfMessageFont.lfHeight = -px(13);
|
||||
let font = CreateFontIndirectW(&metrics.lfMessageFont);
|
||||
if font.is_invalid() {
|
||||
return Err(windows::core::Error::from_thread());
|
||||
}
|
||||
for control in [self.address, self.message, self.retry, self.proceed, self.cancel] {
|
||||
SendMessageW(control, WM_SETFONT, Some(WPARAM(font.0 as usize)), Some(LPARAM(1)));
|
||||
}
|
||||
if let Some((_, old)) = self.font.replace(Some((dpi, font))) {
|
||||
let _ = DeleteObject(old.into());
|
||||
}
|
||||
}
|
||||
MoveWindow(
|
||||
self.address,
|
||||
px(8),
|
||||
px(5),
|
||||
(width - px(16)).max(0),
|
||||
px(ADDRESS_HEIGHT),
|
||||
true,
|
||||
)?;
|
||||
// A one-line formatting rectangle centers the native read-only edit text.
|
||||
// ES_AUTOHSCROLL keeps long URLs on one line and lets users select/copy them.
|
||||
let mut client = RECT::default();
|
||||
GetClientRect(self.address, &mut client)?;
|
||||
let dc = GetDC(Some(self.address));
|
||||
let previous = SelectObject(dc, self.font.get().expect("font initialized").1.into());
|
||||
let mut text_metrics = TEXTMETRICW::default();
|
||||
let measured = GetTextMetricsW(dc, &mut text_metrics);
|
||||
SelectObject(dc, previous);
|
||||
ReleaseDC(Some(self.address), dc);
|
||||
measured.ok()?;
|
||||
let top = ((client.bottom - text_metrics.tmHeight) / 2).max(0);
|
||||
let text = RECT {
|
||||
left: px(6),
|
||||
top,
|
||||
right: client.right - px(6),
|
||||
bottom: top + text_metrics.tmHeight,
|
||||
};
|
||||
SendMessageW(
|
||||
self.address,
|
||||
EM_SETRECT,
|
||||
Some(WPARAM(0)),
|
||||
Some(LPARAM(&text as *const _ as isize)),
|
||||
);
|
||||
let status = self.status.get();
|
||||
let header = if status == RecoveryStatus::Hidden {
|
||||
TOOLBAR_HEIGHT
|
||||
} else {
|
||||
TOOLBAR_HEIGHT + 68
|
||||
};
|
||||
MoveWindow(
|
||||
self.message,
|
||||
px(8),
|
||||
px(TOOLBAR_HEIGHT + 2),
|
||||
(width - px(16)).max(0),
|
||||
px(38),
|
||||
true,
|
||||
)?;
|
||||
let mut right = width - px(8);
|
||||
for (hwnd, visible, size) in [
|
||||
(self.cancel, status.blocks_page(), 70),
|
||||
(self.proceed, status.can_continue(), 136),
|
||||
(self.retry, status.can_retry(), 84),
|
||||
] {
|
||||
if visible {
|
||||
right -= px(size);
|
||||
MoveWindow(hwnd, right, px(TOOLBAR_HEIGHT + 38), px(size), px(28), true)?;
|
||||
right -= px(6);
|
||||
}
|
||||
}
|
||||
let content_height = (bounds.bottom - px(header)).max(0);
|
||||
MoveWindow(self.webview_host, 0, px(header), width, content_height, true)?;
|
||||
state.controller.SetBounds(RECT {
|
||||
left: 0,
|
||||
top: 0,
|
||||
right: width,
|
||||
bottom: content_height,
|
||||
})?;
|
||||
let _ = InvalidateRect(Some(self.parent), None, true);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Controls {
|
||||
fn drop(&mut self) {
|
||||
if let Some((_, font)) = self.font.get() {
|
||||
unsafe {
|
||||
let _ = DeleteObject(font.into());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Keep the native edit's selection and accessibility, with a quiet, flat frame.
|
||||
unsafe extern "system" fn address_proc(
|
||||
hwnd: HWND,
|
||||
msg: u32,
|
||||
wparam: WPARAM,
|
||||
lparam: LPARAM,
|
||||
id: usize,
|
||||
_: usize,
|
||||
) -> LRESULT {
|
||||
if msg == WM_NCDESTROY {
|
||||
unsafe {
|
||||
let _ = RemoveWindowSubclass(hwnd, Some(address_proc), id);
|
||||
}
|
||||
}
|
||||
let result = unsafe { DefSubclassProc(hwnd, msg, wparam, lparam) };
|
||||
// EDIT also repaints its frame during WM_PAINT, so style it after native drawing.
|
||||
if matches!(msg, WM_NCPAINT | WM_PAINT) {
|
||||
unsafe {
|
||||
let dc = GetWindowDC(Some(hwnd));
|
||||
let mut bounds = RECT::default();
|
||||
if !dc.is_invalid() && GetWindowRect(hwnd, &mut bounds).is_ok() {
|
||||
let background = GetSysColor(COLOR_3DFACE);
|
||||
let foreground = GetSysColor(COLOR_WINDOWTEXT);
|
||||
let mut border = 0;
|
||||
for shift in [0, 8, 16] {
|
||||
let channel = (((background >> shift) & 255) * 82 + ((foreground >> shift) & 255) * 18) / 100;
|
||||
border |= channel << shift;
|
||||
}
|
||||
let brush = CreateSolidBrush(COLORREF(border));
|
||||
FrameRect(
|
||||
dc,
|
||||
&RECT {
|
||||
left: 0,
|
||||
top: 0,
|
||||
right: bounds.right - bounds.left,
|
||||
bottom: bounds.bottom - bounds.top,
|
||||
},
|
||||
brush,
|
||||
);
|
||||
let _ = DeleteObject(brush.into());
|
||||
}
|
||||
ReleaseDC(Some(hwnd), dc);
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
unsafe extern "system" fn window_proc(
|
||||
hwnd: HWND,
|
||||
msg: u32,
|
||||
wparam: WPARAM,
|
||||
lparam: LPARAM,
|
||||
id: usize,
|
||||
key: usize,
|
||||
) -> LRESULT {
|
||||
let state = STATES.with_borrow(|states| states.get(&key).cloned());
|
||||
// Paint the native toolbar and recovery surface outside the child webview.
|
||||
if msg == WM_ERASEBKGND {
|
||||
unsafe {
|
||||
let mut bounds = RECT::default();
|
||||
if GetClientRect(hwnd, &mut bounds).is_ok() {
|
||||
FillRect(HDC(wparam.0 as *mut _), &bounds, GetSysColorBrush(COLOR_WINDOW));
|
||||
}
|
||||
}
|
||||
return LRESULT(1);
|
||||
}
|
||||
if let Some(state) = &state {
|
||||
if msg == WM_COMMAND && (wparam.0 >> 16) == BN_CLICKED as usize {
|
||||
let event = match wparam.0 & 0xffff {
|
||||
RETRY => Some(AuthEvent::Retry),
|
||||
PROCEED => Some(AuthEvent::RequestTlsException),
|
||||
CANCEL => Some(AuthEvent::Close),
|
||||
_ => None,
|
||||
};
|
||||
if let Some(event) = event {
|
||||
state.messenger.send_auth_event(event);
|
||||
return LRESULT(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
let result = unsafe { DefSubclassProc(hwnd, msg, wparam, lparam) };
|
||||
if msg == WM_SIZE || msg == WM_DPICHANGED {
|
||||
if let Some(state) = &state {
|
||||
let _ = state.controls.layout(state);
|
||||
}
|
||||
}
|
||||
if msg == WM_NCDESTROY {
|
||||
unsafe {
|
||||
let _ = RemoveWindowSubclass(hwnd, Some(window_proc), id);
|
||||
}
|
||||
STATES.with_borrow_mut(|states| states.remove(&key));
|
||||
if let Some(state) = state {
|
||||
super::tls::clear_exceptions(&state.core);
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
use super::super::tls::{TlsFailure, TlsFailureReason};
|
||||
use super::*;
|
||||
use std::collections::HashSet;
|
||||
use webview2_com::{ClearServerCertificateErrorActionsCompletedHandler, ServerCertificateErrorDetectedEventHandler};
|
||||
use windows::Win32::UI::WindowsAndMessaging::{IDYES, MB_DEFBUTTON2, MB_ICONWARNING, MB_YESNO, MessageBoxW};
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct Policy {
|
||||
pub ignore_errors: bool,
|
||||
approved: HashSet<(String, String)>,
|
||||
pending: Option<Failure>,
|
||||
}
|
||||
#[derive(Clone)]
|
||||
struct Failure {
|
||||
identity: (String, String),
|
||||
failure: TlsFailure,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
fn reason(error: COREWEBVIEW2_WEB_ERROR_STATUS) -> TlsFailureReason {
|
||||
match error {
|
||||
COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_COMMON_NAME_IS_INCORRECT => TlsFailureReason::HostnameMismatch,
|
||||
COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_EXPIRED => TlsFailureReason::Expired,
|
||||
_ => TlsFailureReason::InvalidCertificate,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn install(state: &Rc<State>) -> windows::core::Result<()> {
|
||||
let weak = Rc::downgrade(state);
|
||||
let handler = ServerCertificateErrorDetectedEventHandler::create(Box::new(move |_, args| {
|
||||
let (Some(state), Some(args)) = (weak.upgrade(), args) else {
|
||||
return Ok(());
|
||||
};
|
||||
unsafe {
|
||||
let uri = text(|p| args.RequestUri(p))?;
|
||||
let host = url::Url::parse(&uri)
|
||||
.ok()
|
||||
.and_then(|url| url.host_str().map(str::to_owned))
|
||||
.unwrap_or_default();
|
||||
let pem = text(|p| args.ServerCertificate()?.ToPemEncoding(p))?;
|
||||
let mut error = COREWEBVIEW2_WEB_ERROR_STATUS_UNKNOWN;
|
||||
args.ErrorStatus(&mut error)?;
|
||||
let identity = (host.clone(), pem);
|
||||
let mut policy = state.tls.borrow_mut();
|
||||
if policy.ignore_errors || policy.approved.contains(&identity) {
|
||||
args.SetAction(COREWEBVIEW2_SERVER_CERTIFICATE_ERROR_ACTION_ALWAYS_ALLOW)?;
|
||||
} else {
|
||||
args.SetAction(COREWEBVIEW2_SERVER_CERTIFICATE_ERROR_ACTION_CANCEL)?;
|
||||
let generation = state.document.borrow().1;
|
||||
let failure = TlsFailure {
|
||||
host,
|
||||
reason: reason(error),
|
||||
can_continue: error != COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_REVOKED,
|
||||
};
|
||||
state
|
||||
.messenger
|
||||
.send_auth_event(AuthEvent::Error(generation, AuthError::Tls(failure.clone())));
|
||||
policy.pending = Some(Failure {
|
||||
identity,
|
||||
failure,
|
||||
generation,
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}));
|
||||
let mut token = 0;
|
||||
unsafe {
|
||||
state
|
||||
.core
|
||||
.cast::<ICoreWebView2_14>()?
|
||||
.add_ServerCertificateErrorDetected(&handler, &mut token)
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn confirm(state: &State) -> anyhow::Result<()> {
|
||||
let pending = state
|
||||
.tls
|
||||
.borrow()
|
||||
.pending
|
||||
.clone()
|
||||
.context("No certificate error to confirm")?;
|
||||
if !pending.failure.can_continue || pending.generation != state.messenger.generation() {
|
||||
bail!("This certificate exception is no longer available");
|
||||
}
|
||||
let answer = unsafe {
|
||||
MessageBoxW(
|
||||
Some(state.controls.parent),
|
||||
&HSTRING::from(pending.failure.confirmation_message()),
|
||||
&HSTRING::from(pending.failure.confirmation_title()),
|
||||
MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2,
|
||||
)
|
||||
};
|
||||
if answer == IDYES {
|
||||
let identity = pending.identity.clone();
|
||||
let generation = pending.generation;
|
||||
state.tls.borrow_mut().approved.insert(identity);
|
||||
state.messenger.send_auth_event(AuthEvent::TlsAccepted(generation));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// WebView2 caches approvals in the session. Do not leave them for another sign-in window.
|
||||
pub(super) fn clear_exceptions(core: &ICoreWebView2) {
|
||||
if let Ok(core) = core.cast::<ICoreWebView2_14>() {
|
||||
let _ = unsafe {
|
||||
core.ClearServerCertificateErrorActions(&ClearServerCertificateErrorActionsCompletedHandler::create(Box::new(
|
||||
|_| Ok(()),
|
||||
)))
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn maps_certificate_failure_reasons() {
|
||||
assert_eq!(
|
||||
reason(COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_COMMON_NAME_IS_INCORRECT),
|
||||
TlsFailureReason::HostnameMismatch
|
||||
);
|
||||
assert_eq!(
|
||||
reason(COREWEBVIEW2_WEB_ERROR_STATUS_CERTIFICATE_EXPIRED),
|
||||
TlsFailureReason::Expired
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -16,4 +16,7 @@ which = { workspace = true, optional = true }
|
||||
|
||||
[features]
|
||||
default = []
|
||||
launcher = ["dep:open", "dep:webbrowser", "dep:which"]
|
||||
launcher = ["dep:open", "dep:webbrowser", "dep:which", "dep:winreg"]
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
winreg = { version = "0.55", optional = true }
|
||||
@@ -1,8 +1,11 @@
|
||||
#[cfg(all(feature = "launcher", windows))]
|
||||
#[path = "platform/windows.rs"]
|
||||
mod platform;
|
||||
#[cfg(all(feature = "launcher", target_os = "macos"))]
|
||||
#[path = "platform/macos.rs"]
|
||||
mod platform;
|
||||
|
||||
#[cfg(all(feature = "launcher", not(target_os = "macos")))]
|
||||
#[cfg(all(feature = "launcher", unix, not(target_os = "macos")))]
|
||||
#[path = "platform/generic.rs"]
|
||||
mod platform;
|
||||
|
||||
@@ -38,7 +41,7 @@ impl<'a> Browser<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(feature = "launcher", not(target_os = "macos")))]
|
||||
#[cfg(all(feature = "launcher", unix, not(target_os = "macos")))]
|
||||
pub(crate) fn as_str(&self) -> &str {
|
||||
match self {
|
||||
Browser::Auto => "auto",
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
//! Windows browsers are resolved through their registered App Paths.
|
||||
use crate::Browser;
|
||||
use anyhow::{Context, bail};
|
||||
use std::path::PathBuf;
|
||||
use winreg::{
|
||||
RegKey,
|
||||
enums::{HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE},
|
||||
};
|
||||
|
||||
pub(super) fn open_url(url: &str, browser: Browser<'_>) -> anyhow::Result<()> {
|
||||
let executable = match browser {
|
||||
Browser::Auto | Browser::Default => return webbrowser::open(url).context("Could not open the browser"),
|
||||
Browser::Chrome => registered_browser("chrome.exe").context("Chrome is not installed")?,
|
||||
Browser::Edge => registered_browser("msedge.exe").context("Edge is not installed")?,
|
||||
Browser::Firefox => registered_browser("firefox.exe").context("Firefox is not installed")?,
|
||||
Browser::Safari => bail!("Safari is not available on Windows"),
|
||||
Browser::Other(program) => PathBuf::from(program),
|
||||
};
|
||||
std::process::Command::new(executable)
|
||||
.arg(url)
|
||||
.spawn()
|
||||
.context("Could not open the configured browser")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn registered_browser(name: &str) -> Option<PathBuf> {
|
||||
[HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE].into_iter().find_map(|hive| {
|
||||
let key = RegKey::predef(hive)
|
||||
.open_subkey(format!(r"Software\Microsoft\Windows\CurrentVersion\App Paths\{name}"))
|
||||
.ok()?;
|
||||
let path: String = key.get_value("").ok()?;
|
||||
let path = PathBuf::from(path.trim_matches('"'));
|
||||
path.is_file().then_some(path)
|
||||
})
|
||||
}
|
||||
+10
-5
@@ -5,11 +5,16 @@ fn main() {
|
||||
let workspace_dir = Path::new(manifest_dir).ancestors().nth(2).unwrap();
|
||||
let gpgui_dir = workspace_dir.parent().unwrap().join("gpgui");
|
||||
|
||||
let gp_service_binary = workspace_dir.join("target/debug/gpservice");
|
||||
let gp_client_binary = workspace_dir.join("target/debug/gpclient");
|
||||
let gp_auth_binary = workspace_dir.join("target/debug/gpauth");
|
||||
let gp_gui_helper_binary = workspace_dir.join("target/debug/gpgui-helper");
|
||||
let gp_gui_binary = gpgui_dir.join("target/debug/gpgui");
|
||||
let suffix = if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
|
||||
".exe"
|
||||
} else {
|
||||
""
|
||||
};
|
||||
let gp_service_binary = workspace_dir.join(format!("target/debug/gpservice{suffix}"));
|
||||
let gp_client_binary = workspace_dir.join(format!("target/debug/gpclient{suffix}"));
|
||||
let gp_auth_binary = workspace_dir.join(format!("target/debug/gpauth{suffix}"));
|
||||
let gp_gui_helper_binary = workspace_dir.join(format!("target/debug/gpgui-helper{suffix}"));
|
||||
let gp_gui_binary = gpgui_dir.join(format!("target/debug/gpgui{suffix}"));
|
||||
|
||||
println!("cargo:rustc-env=GP_SERVICE_BINARY={}", gp_service_binary.display());
|
||||
println!("cargo:rustc-env=GP_CLIENT_BINARY={}", gp_client_binary.display());
|
||||
|
||||
@@ -89,7 +89,7 @@ fn sibling_binary(binary_name: &str) -> Option<PathBuf> {
|
||||
fn sibling_binary_for_executable(executable: &Path, binary_name: &str) -> Option<PathBuf> {
|
||||
let executable = executable.canonicalize().ok()?;
|
||||
let bin_dir = executable.parent()?;
|
||||
let binary = bin_dir.join(binary_name);
|
||||
let binary = bin_dir.join(format!("{binary_name}{}", std::env::consts::EXE_SUFFIX));
|
||||
if is_file(&binary) {
|
||||
return Some(binary);
|
||||
}
|
||||
|
||||
@@ -2,7 +2,6 @@ pub const GP_USER_AGENT: &str = "PAN GlobalProtect";
|
||||
pub const GP_CLIENT_VERSION_LINUX: &str = "6.3.3-619";
|
||||
pub const GP_CLIENT_VERSION_WINDOWS: &str = "6.3.3-650";
|
||||
pub const GP_CLIENT_VERSION_MACOS: &str = "6.3.3-915";
|
||||
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")]
|
||||
|
||||
@@ -1,2 +1,3 @@
|
||||
pub mod binary_paths;
|
||||
pub mod constants;
|
||||
pub mod paths;
|
||||
@@ -0,0 +1,32 @@
|
||||
//! Machine-wide service state shared by the daemon and desktop clients.
|
||||
use std::path::PathBuf;
|
||||
|
||||
pub fn service_lock_file() -> PathBuf {
|
||||
#[cfg(unix)]
|
||||
{
|
||||
PathBuf::from("/var/run/gpservice.lock")
|
||||
}
|
||||
#[cfg(windows)]
|
||||
{
|
||||
std::env::var_os("ProgramData")
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| PathBuf::from(r"C:\ProgramData"))
|
||||
.join("GP Connect")
|
||||
.join("gpservice.lock")
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
pub const SERVICE_PIPE: &str = r"\\.\pipe\GPConnect.Service";
|
||||
|
||||
#[cfg(windows)]
|
||||
pub const SERVICE_NAME: &str = "GPConnect";
|
||||
|
||||
/// Installer-owned SYSTEM/Administrators-only state, including temporary keys.
|
||||
#[cfg(windows)]
|
||||
pub fn service_private_dir() -> PathBuf {
|
||||
service_lock_file()
|
||||
.parent()
|
||||
.expect("service state directory")
|
||||
.join("Private")
|
||||
}
|
||||
+10
-2
@@ -6,7 +6,6 @@ edition.workspace = true
|
||||
license = "MIT"
|
||||
|
||||
[dependencies]
|
||||
nix = { version = "0.31", features = ["fs", "signal", "process"], optional = true }
|
||||
common = { path = "../common" }
|
||||
anyhow.workspace = true
|
||||
base64.workspace = true
|
||||
@@ -35,7 +34,6 @@ thiserror.workspace = true
|
||||
chacha20poly1305 = { version = "0.11", features = ["zeroize"] }
|
||||
url.workspace = true
|
||||
regex.workspace = true
|
||||
uzers = { workspace = true, optional = true }
|
||||
serde_urlencoded.workspace = true
|
||||
md5.workspace = true
|
||||
sha2.workspace = true
|
||||
@@ -90,3 +88,13 @@ tauri = ["desktop", "dep:tauri", "dep:gtk", "dep:os_info"]
|
||||
clap = ["desktop", "dep:clap", "dep:clap-verbosity-flag"]
|
||||
webview-auth = []
|
||||
logger = ["desktop", "dep:env_logger", "dep:log-reload", "dep:oslog"]
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
nix = { version = "0.31", features = ["fs", "signal", "process"], optional = true }
|
||||
uzers = { workspace = true, optional = true }
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows-sys = { version = "0.61", features = ["Win32_NetworkManagement_IpHelper", "Win32_NetworkManagement_Ndis", "Win32_Networking_WinSock", "Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_Pipes", "Win32_System_Threading", "Win32_System_Services", "Win32_Globalization", "Win32_System_Environment", "Win32_System_JobObjects", "Win32_System_IO"] }
|
||||
|
||||
[target.'cfg(windows)'.dev-dependencies]
|
||||
windows-sys = { version = "0.61", features = ["Win32_UI_Shell"] }
|
||||
@@ -10,6 +10,7 @@ pub enum AnchorSource {
|
||||
UnixMac,
|
||||
UnixRandom,
|
||||
MacosIokit,
|
||||
WindowsSmbios,
|
||||
}
|
||||
|
||||
impl From<AnchorSource> for u8 {
|
||||
@@ -18,6 +19,7 @@ impl From<AnchorSource> for u8 {
|
||||
AnchorSource::UnixMac => 1,
|
||||
AnchorSource::UnixRandom => 2,
|
||||
AnchorSource::MacosIokit => 3,
|
||||
AnchorSource::WindowsSmbios => 4,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -41,6 +43,7 @@ impl TryFrom<u8> for AnchorSource {
|
||||
1 => Ok(Self::UnixMac),
|
||||
2 => Ok(Self::UnixRandom),
|
||||
3 => Ok(Self::MacosIokit),
|
||||
4 => Ok(Self::WindowsSmbios),
|
||||
value => Err(InvalidAnchorSource(value)),
|
||||
}
|
||||
}
|
||||
@@ -65,6 +68,7 @@ impl DeviceAnchor {
|
||||
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(),
|
||||
AnchorSource::WindowsSmbios => b"gp-device-anchor:v1:windows-smbios-uuid:".as_slice(),
|
||||
};
|
||||
let mut input = domain.to_vec();
|
||||
input.extend_from_slice(seed.as_ref());
|
||||
@@ -81,7 +85,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn preserves_existing_hardware_ids_for_all_sources() {
|
||||
let cases: [(AnchorSource, &[u8], &str); 3] = [
|
||||
let cases: [(AnchorSource, &[u8], &str); 4] = [
|
||||
(
|
||||
AnchorSource::UnixMac,
|
||||
&[0, 17, 34, 51, 68, 85],
|
||||
@@ -97,6 +101,11 @@ mod tests {
|
||||
b"12345678-1234-5678-9abc-def012345678",
|
||||
"K1KMtAwiOiXKQvQuRmTDKPA6-ZPF5QKUWZzmvRzeP34",
|
||||
),
|
||||
(
|
||||
AnchorSource::WindowsSmbios,
|
||||
b"12345678-1234-5678-9abc-def012345678",
|
||||
"C843jG-lDX91Tab02VelrMJl_OmOji_pCtNWilwzW5s",
|
||||
),
|
||||
];
|
||||
for (source, seed, expected) in cases {
|
||||
let anchor = DeviceAnchor::derive(source, seed);
|
||||
@@ -124,12 +133,17 @@ mod tests {
|
||||
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::to_string(&AnchorSource::WindowsSmbios).unwrap(), "4");
|
||||
assert_eq!(
|
||||
serde_json::from_str::<AnchorSource>("4").unwrap(),
|
||||
AnchorSource::WindowsSmbios
|
||||
);
|
||||
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>("5").is_err());
|
||||
assert!(serde_json::from_str::<AnchorSource>(r#""unix_mac""#).is_err());
|
||||
}
|
||||
}
|
||||
@@ -31,3 +31,6 @@ pub mod clap;
|
||||
|
||||
#[cfg(feature = "desktop")]
|
||||
pub mod script_tun;
|
||||
|
||||
#[cfg(all(feature = "desktop", windows))]
|
||||
pub mod windows;
|
||||
@@ -236,7 +236,7 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
}
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
{
|
||||
if self.browser.is_none() {
|
||||
if self.hidpi {
|
||||
auth_cmd.arg("--hidpi");
|
||||
}
|
||||
@@ -409,6 +409,42 @@ mod tests {
|
||||
assert!(args.iter().any(|arg| arg == "--ignore-tls-errors"));
|
||||
}
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
#[test]
|
||||
fn external_browser_receives_no_embedded_window_arguments() {
|
||||
let args = child_args(
|
||||
SamlAuthLauncher::new("vpn.example.com")
|
||||
.browser(Some("edge"))
|
||||
.clean(true)
|
||||
.hidpi(true)
|
||||
.window_title("GP Connect Login")
|
||||
.window_theme(AuthWindowTheme::Dark),
|
||||
);
|
||||
assert!(args.windows(2).any(|pair| pair == ["--browser", "edge"]));
|
||||
for option in ["--clean", "--hidpi", "--window-title", "--window-theme"] {
|
||||
assert!(!args.iter().any(|arg| arg == option), "unexpected {option} in {args:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
#[test]
|
||||
fn embedded_window_receives_auth_preferences() {
|
||||
let args = child_args(
|
||||
SamlAuthLauncher::new("vpn.example.com")
|
||||
.clean(true)
|
||||
.window_title("GP Connect Login")
|
||||
.window_theme(AuthWindowTheme::Dark),
|
||||
);
|
||||
assert!(args.iter().any(|arg| arg == "--clean"));
|
||||
assert!(
|
||||
args
|
||||
.windows(2)
|
||||
.any(|pair| pair == ["--window-title", "GP Connect Login"])
|
||||
);
|
||||
assert!(args.windows(2).any(|pair| pair == ["--window-theme", "dark"]));
|
||||
assert!(!args.iter().any(|arg| arg == "--browser"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn os_profile_sets_os_from_profile() {
|
||||
let profile = OsProfileBuilder::new(ClientOs::Linux)
|
||||
|
||||
@@ -1,20 +1,41 @@
|
||||
#[cfg(unix)]
|
||||
mod command_runner;
|
||||
#[cfg(windows)]
|
||||
#[path = "windows/command_runner.rs"]
|
||||
mod command_runner;
|
||||
#[cfg(unix)]
|
||||
mod command_traits;
|
||||
#[cfg(windows)]
|
||||
#[path = "windows/command_traits.rs"]
|
||||
mod command_traits;
|
||||
#[cfg(unix)]
|
||||
mod desktop_child;
|
||||
#[cfg(unix)]
|
||||
mod desktop_session_env;
|
||||
#[cfg(unix)]
|
||||
pub(crate) mod gui_helper_launcher;
|
||||
|
||||
pub use command_traits::CommandExt;
|
||||
|
||||
pub mod auth_launcher;
|
||||
#[cfg(unix)]
|
||||
pub mod desktop_launcher;
|
||||
#[cfg(unix)]
|
||||
pub mod gui_launcher;
|
||||
#[cfg(any(target_os = "linux", test))]
|
||||
pub mod gui_switch;
|
||||
#[cfg(any(target_os = "linux", test))]
|
||||
mod nsh_runtime;
|
||||
#[cfg(unix)]
|
||||
pub mod users;
|
||||
|
||||
#[cfg(unix)]
|
||||
pub mod collection;
|
||||
#[cfg(windows)]
|
||||
#[path = "windows/collection.rs"]
|
||||
pub mod collection;
|
||||
|
||||
pub mod rendering_recovery;
|
||||
#[cfg(windows)]
|
||||
#[path = "windows/user_process.rs"]
|
||||
pub mod user_process;
|
||||
@@ -49,11 +49,17 @@ impl RecoveryState {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
pub(crate) fn is_crash_exit(status: ExitStatus) -> bool {
|
||||
use std::os::unix::process::ExitStatusExt;
|
||||
!status.success() && !matches!(status.signal(), Some(1 | 2 | 9 | 15))
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
pub(crate) fn is_crash_exit(status: ExitStatus) -> bool {
|
||||
status.code().is_some_and(|code| (code as u32) >= 0xC0000000)
|
||||
}
|
||||
|
||||
pub fn eligible(command: &Command) -> bool {
|
||||
eligible_with_inheritance(command, true)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
//! Resolve system collectors from Windows' system directory, never the working directory.
|
||||
use super::command_runner::run_controlled;
|
||||
use crate::collection::CollectionControl;
|
||||
use std::{
|
||||
io,
|
||||
path::{Path, PathBuf},
|
||||
process::{Command, Output},
|
||||
};
|
||||
|
||||
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> {
|
||||
let system = std::env::var_os("SystemRoot")?;
|
||||
let path = PathBuf::from(system).join("System32").join(name).with_extension("exe");
|
||||
path.is_file().then_some(path)
|
||||
}
|
||||
pub fn run(&self, name: &str, args: &[&str]) -> io::Result<Option<Output>> {
|
||||
self.control.check()?;
|
||||
match self.resolve(name) {
|
||||
Some(path) => self.run_path(&path, args),
|
||||
None => Ok(None),
|
||||
}
|
||||
}
|
||||
pub fn run_executable(&self, path: &Path, args: &[&str]) -> io::Result<Option<Output>> {
|
||||
self.run_path(path, args)
|
||||
}
|
||||
pub fn run_path(&self, path: &Path, args: &[&str]) -> io::Result<Option<Output>> {
|
||||
self.control.check()?;
|
||||
let mut command = Command::new(path);
|
||||
command.args(args);
|
||||
match run_controlled(command, self.control, 256 * 1024) {
|
||||
Ok(output) => Ok(Some(output)),
|
||||
Err(error) if matches!(error.kind(), io::ErrorKind::NotFound | io::ErrorKind::PermissionDenied) => Ok(None),
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
//! Controlled Windows child execution. Pipe polling keeps cancellation responsive.
|
||||
use crate::collection::CollectionControl;
|
||||
use std::{
|
||||
io::{self, Read, Write},
|
||||
os::windows::io::AsRawHandle,
|
||||
process::{Child, Command, Output, Stdio},
|
||||
thread,
|
||||
time::Duration,
|
||||
};
|
||||
use windows_sys::Win32::System::Pipes::PeekNamedPipe;
|
||||
|
||||
pub(crate) enum ChildInput<'a> {
|
||||
Null,
|
||||
Terminal,
|
||||
// Preserve the borrowed input type shared by callers without a Windows launcher.
|
||||
#[allow(dead_code)]
|
||||
Frame(&'a [u8]),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct ObservedOutput {
|
||||
pub output: Output,
|
||||
}
|
||||
|
||||
pub(crate) fn run_controlled(command: Command, control: &dyn CollectionControl, limit: usize) -> io::Result<Output> {
|
||||
run_observed(
|
||||
command,
|
||||
control,
|
||||
Some(limit),
|
||||
&mut |_| {},
|
||||
&mut io::sink(),
|
||||
ChildInput::Null,
|
||||
)
|
||||
.map(|observed| observed.output)
|
||||
}
|
||||
|
||||
pub(crate) fn run_observed(
|
||||
mut command: Command,
|
||||
control: &dyn CollectionControl,
|
||||
output_limit: Option<usize>,
|
||||
observer: &mut dyn FnMut(&[u8]),
|
||||
stderr_sink: &mut dyn Write,
|
||||
stdin: ChildInput<'_>,
|
||||
) -> io::Result<ObservedOutput> {
|
||||
control.check()?;
|
||||
// Windows desktop processes must not open a console for each helper.
|
||||
use std::os::windows::process::CommandExt;
|
||||
if !matches!(stdin, ChildInput::Terminal) {
|
||||
command.creation_flags(0x08000000); // CREATE_NO_WINDOW
|
||||
}
|
||||
command.stdout(if output_limit.is_some() {
|
||||
Stdio::piped()
|
||||
} else {
|
||||
Stdio::inherit()
|
||||
});
|
||||
command.stderr(Stdio::piped());
|
||||
command.stdin(match stdin {
|
||||
ChildInput::Terminal => Stdio::inherit(),
|
||||
ChildInput::Null => Stdio::null(),
|
||||
ChildInput::Frame(_) => Stdio::piped(),
|
||||
});
|
||||
let mut child = ControlledChild(command.spawn()?);
|
||||
let input = if let ChildInput::Frame(frame) = stdin {
|
||||
let mut pipe = child.0.stdin.take().expect("piped stdin");
|
||||
let frame = frame.to_vec();
|
||||
Some(thread::spawn(move || pipe.write_all(&frame)))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut stdout = child.0.stdout.take();
|
||||
let mut stderr = child.0.stderr.take().expect("piped stderr");
|
||||
let mut output = Vec::new();
|
||||
let mut buffer = [0u8; 8192];
|
||||
loop {
|
||||
control.check()?;
|
||||
if let Some(pipe) = &mut stdout {
|
||||
let length = read_available(pipe, &mut buffer)?;
|
||||
if length > output_limit.unwrap().saturating_sub(output.len()) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
"Command output exceeds its limit",
|
||||
));
|
||||
}
|
||||
output.extend_from_slice(&buffer[..length]);
|
||||
}
|
||||
let length = read_available(&mut stderr, &mut buffer)?;
|
||||
observer(&buffer[..length]);
|
||||
stderr_sink.write_all(&buffer[..length])?;
|
||||
if let Some(status) = child.0.try_wait()? {
|
||||
// Drain the remaining buffered output after the process exits.
|
||||
if let Some(pipe) = &mut stdout {
|
||||
loop {
|
||||
let length = read_available(pipe, &mut buffer)?;
|
||||
if length == 0 {
|
||||
break;
|
||||
}
|
||||
if length > output_limit.unwrap().saturating_sub(output.len()) {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
"Command output exceeds its limit",
|
||||
));
|
||||
}
|
||||
output.extend_from_slice(&buffer[..length]);
|
||||
}
|
||||
}
|
||||
loop {
|
||||
let length = read_available(&mut stderr, &mut buffer)?;
|
||||
if length == 0 {
|
||||
break;
|
||||
}
|
||||
observer(&buffer[..length]);
|
||||
stderr_sink.write_all(&buffer[..length])?;
|
||||
}
|
||||
if let Some(result) = input.and_then(|worker| worker.join().ok()) {
|
||||
result?;
|
||||
}
|
||||
return Ok(ObservedOutput {
|
||||
output: Output {
|
||||
status,
|
||||
stdout: output,
|
||||
stderr: Vec::new(),
|
||||
},
|
||||
});
|
||||
}
|
||||
thread::sleep(Duration::from_millis(10));
|
||||
}
|
||||
}
|
||||
|
||||
fn read_available(pipe: &mut (impl Read + AsRawHandle), buffer: &mut [u8]) -> io::Result<usize> {
|
||||
let mut available = 0;
|
||||
let success = unsafe {
|
||||
PeekNamedPipe(
|
||||
pipe.as_raw_handle(),
|
||||
std::ptr::null_mut(),
|
||||
0,
|
||||
std::ptr::null_mut(),
|
||||
&mut available,
|
||||
std::ptr::null_mut(),
|
||||
)
|
||||
};
|
||||
if success == 0 {
|
||||
let error = io::Error::last_os_error();
|
||||
if error.raw_os_error() == Some(109) {
|
||||
return Ok(0);
|
||||
} // ERROR_BROKEN_PIPE
|
||||
return Err(error);
|
||||
}
|
||||
let length = buffer.len().min(available as usize);
|
||||
if length == 0 {
|
||||
return Ok(0);
|
||||
}
|
||||
pipe.read(&mut buffer[..length])
|
||||
}
|
||||
|
||||
struct ControlledChild(Child);
|
||||
impl Drop for ControlledChild {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.0.kill();
|
||||
let _ = self.0.wait();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn captures_output_and_rejects_excess_output() {
|
||||
let mut command = Command::new("cmd.exe");
|
||||
command.args(["/D", "/C", "echo hello"]);
|
||||
let result = run_controlled(command, &|| Ok(()), 1024).unwrap();
|
||||
assert!(result.status.success());
|
||||
assert_eq!(String::from_utf8(result.stdout).unwrap().trim(), "hello");
|
||||
let mut command = Command::new("cmd.exe");
|
||||
command.args(["/D", "/C", "echo too much"]);
|
||||
assert_eq!(
|
||||
run_controlled(command, &|| Ok(()), 2).unwrap_err().kind(),
|
||||
io::ErrorKind::InvalidData
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn cancels_a_running_helper() {
|
||||
let start = std::time::Instant::now();
|
||||
let mut command = Command::new("powershell.exe");
|
||||
command.args(["-NoProfile", "-Command", "Start-Sleep -Seconds 30"]);
|
||||
let control = || {
|
||||
if start.elapsed() > Duration::from_millis(150) {
|
||||
Err(io::Error::new(io::ErrorKind::Interrupted, "cancelled"))
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
};
|
||||
assert_eq!(
|
||||
run_controlled(command, &control, 1024).unwrap_err().kind(),
|
||||
io::ErrorKind::Interrupted
|
||||
);
|
||||
assert!(start.elapsed() < Duration::from_secs(3));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
use tokio::process::Command;
|
||||
|
||||
/// Windows authentication runs in the interactive user's GUI process.
|
||||
pub trait CommandExt {
|
||||
fn into_non_root(self) -> anyhow::Result<Command>;
|
||||
}
|
||||
|
||||
impl CommandExt for Command {
|
||||
fn into_non_root(self) -> anyhow::Result<Command> {
|
||||
Ok(self)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,309 @@
|
||||
//! Launch a native worker with the admitted user's primary token and environment.
|
||||
use std::{
|
||||
ffi::{OsStr, c_void},
|
||||
io,
|
||||
os::windows::{
|
||||
ffi::OsStrExt,
|
||||
io::{AsRawHandle, BorrowedHandle, FromRawHandle, OwnedHandle},
|
||||
},
|
||||
path::Path,
|
||||
ptr,
|
||||
};
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{WAIT_OBJECT_0, WAIT_TIMEOUT},
|
||||
Globalization::{CSTR_EQUAL, CompareStringOrdinal},
|
||||
Security::{ImpersonateLoggedOnUser, RevertToSelf},
|
||||
System::{
|
||||
Environment::{CreateEnvironmentBlock, DestroyEnvironmentBlock},
|
||||
JobObjects::*,
|
||||
Threading::*,
|
||||
},
|
||||
};
|
||||
|
||||
pub struct UserProcess {
|
||||
process: OwnedHandle,
|
||||
job: Option<OwnedHandle>,
|
||||
pid: u32,
|
||||
}
|
||||
struct Environment(*mut c_void);
|
||||
impl Drop for Environment {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
DestroyEnvironmentBlock(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn invalid(message: &str) -> io::Error {
|
||||
io::Error::new(io::ErrorKind::InvalidInput, message)
|
||||
}
|
||||
fn wide(value: &OsStr) -> io::Result<Vec<u16>> {
|
||||
let value: Vec<_> = value.encode_wide().collect();
|
||||
if value.contains(&0) {
|
||||
return Err(invalid("Windows process strings cannot contain NUL"));
|
||||
}
|
||||
Ok(value)
|
||||
}
|
||||
fn quote(argument: &[u16], output: &mut Vec<u16>) {
|
||||
output.push(b'"' as u16);
|
||||
let mut backslashes = 0;
|
||||
for &character in argument {
|
||||
if character == b'\\' as u16 {
|
||||
backslashes += 1;
|
||||
continue;
|
||||
}
|
||||
let count = if character == b'"' as u16 {
|
||||
backslashes * 2 + 1
|
||||
} else {
|
||||
backslashes
|
||||
};
|
||||
output.extend(std::iter::repeat_n(b'\\' as u16, count));
|
||||
output.push(character);
|
||||
backslashes = 0;
|
||||
}
|
||||
output.extend(std::iter::repeat_n(b'\\' as u16, backslashes * 2));
|
||||
output.push(b'"' as u16);
|
||||
}
|
||||
fn command_line(program: &[u16], arguments: &[String]) -> io::Result<Vec<u16>> {
|
||||
let mut output = Vec::new();
|
||||
quote(program, &mut output);
|
||||
for argument in arguments {
|
||||
output.push(b' ' as u16);
|
||||
quote(&wide(OsStr::new(argument))?, &mut output);
|
||||
}
|
||||
output.push(0);
|
||||
if output.len() > 32767 {
|
||||
return Err(invalid("Windows worker command line is too long"));
|
||||
}
|
||||
Ok(output)
|
||||
}
|
||||
fn key(entry: &[u16]) -> &[u16] {
|
||||
let end = entry
|
||||
.iter()
|
||||
.enumerate()
|
||||
.find(|(index, value)| *index != 0 && **value == b'=' as u16)
|
||||
.map(|(index, _)| index)
|
||||
.unwrap_or(entry.len());
|
||||
&entry[..end]
|
||||
}
|
||||
fn compare(left: &[u16], right: &[u16]) -> std::cmp::Ordering {
|
||||
// Environment names follow Windows' ordinal, case-insensitive ordering.
|
||||
unsafe { CompareStringOrdinal(left.as_ptr(), left.len() as i32, right.as_ptr(), right.len() as i32, 1) }
|
||||
.cmp(&CSTR_EQUAL)
|
||||
}
|
||||
fn user_environment(token: BorrowedHandle<'_>, variables: &[(&str, &str)]) -> io::Result<Vec<u16>> {
|
||||
let mut pointer = ptr::null_mut();
|
||||
if unsafe { CreateEnvironmentBlock(&mut pointer, token.as_raw_handle(), 0) } == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let environment = Environment(pointer);
|
||||
let mut entries = Vec::new();
|
||||
unsafe {
|
||||
let mut current = environment.0.cast::<u16>();
|
||||
while *current != 0 {
|
||||
let mut length = 0;
|
||||
while *current.add(length) != 0 {
|
||||
length += 1;
|
||||
}
|
||||
entries.push(std::slice::from_raw_parts(current, length).to_vec());
|
||||
current = current.add(length + 1);
|
||||
}
|
||||
}
|
||||
for (name, value) in variables {
|
||||
if name.is_empty() || name.contains('=') {
|
||||
return Err(invalid("Invalid worker environment name"));
|
||||
}
|
||||
let name = wide(OsStr::new(name))?;
|
||||
let value = wide(OsStr::new(value))?;
|
||||
entries.retain(|entry| compare(key(entry), &name) != std::cmp::Ordering::Equal);
|
||||
let mut entry = name;
|
||||
entry.push(b'=' as u16);
|
||||
entry.extend(value);
|
||||
entries.push(entry);
|
||||
}
|
||||
entries.sort_by(|left, right| compare(key(left), key(right)));
|
||||
let mut block = Vec::new();
|
||||
for entry in entries {
|
||||
block.extend(entry);
|
||||
block.push(0);
|
||||
}
|
||||
if block.is_empty() {
|
||||
block.push(0);
|
||||
}
|
||||
block.push(0);
|
||||
Ok(block)
|
||||
}
|
||||
impl UserProcess {
|
||||
/// No service handles or service environment are inherited. The user token
|
||||
/// determines the Windows session, including an existing interactive desktop.
|
||||
pub fn launch(
|
||||
token: BorrowedHandle<'_>,
|
||||
program: &Path,
|
||||
arguments: &[String],
|
||||
variables: &[(&str, &str)],
|
||||
) -> io::Result<Self> {
|
||||
if !program.is_absolute() {
|
||||
return Err(invalid("Windows worker executable must be absolute"));
|
||||
}
|
||||
let mut executable = wide(program.as_os_str())?;
|
||||
let mut command = command_line(&executable, arguments)?;
|
||||
executable.push(0);
|
||||
let mut environment = user_environment(token, variables)?;
|
||||
let directory = program.parent().ok_or_else(|| invalid("Worker directory is missing"))?;
|
||||
let mut directory = wide(directory.as_os_str())?;
|
||||
directory.push(0);
|
||||
let job = unsafe { CreateJobObjectW(ptr::null(), ptr::null()) };
|
||||
if job.is_null() {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let job = unsafe { OwnedHandle::from_raw_handle(job) };
|
||||
let limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
|
||||
BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION {
|
||||
LimitFlags: JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
|
||||
..Default::default()
|
||||
},
|
||||
..Default::default()
|
||||
};
|
||||
if unsafe {
|
||||
SetInformationJobObject(
|
||||
job.as_raw_handle(),
|
||||
JobObjectExtendedLimitInformation,
|
||||
(&limits as *const JOBOBJECT_EXTENDED_LIMIT_INFORMATION).cast(),
|
||||
std::mem::size_of_val(&limits) as u32,
|
||||
)
|
||||
} == 0
|
||||
{
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let mut desktop: Vec<u16> = "winsta0\\default".encode_utf16().chain(Some(0)).collect();
|
||||
let startup = STARTUPINFOW {
|
||||
cb: std::mem::size_of::<STARTUPINFOW>() as u32,
|
||||
lpDesktop: desktop.as_mut_ptr(),
|
||||
..Default::default()
|
||||
};
|
||||
let mut information = PROCESS_INFORMATION::default();
|
||||
// Read/execute the requested image as its user, as Unix exec-after-setuid
|
||||
// does. The service's filesystem access must not authorize a private image.
|
||||
if unsafe { ImpersonateLoggedOnUser(token.as_raw_handle()) } == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
struct Revert;
|
||||
impl Drop for Revert {
|
||||
fn drop(&mut self) {
|
||||
if unsafe { RevertToSelf() } == 0 {
|
||||
std::process::abort();
|
||||
}
|
||||
}
|
||||
}
|
||||
let revert = Revert;
|
||||
let created = unsafe {
|
||||
CreateProcessAsUserW(
|
||||
token.as_raw_handle(),
|
||||
executable.as_ptr(),
|
||||
command.as_mut_ptr(),
|
||||
ptr::null(),
|
||||
ptr::null(),
|
||||
0,
|
||||
CREATE_UNICODE_ENVIRONMENT | CREATE_SUSPENDED | CREATE_NO_WINDOW,
|
||||
environment.as_mut_ptr().cast(),
|
||||
directory.as_ptr(),
|
||||
&startup,
|
||||
&mut information,
|
||||
)
|
||||
};
|
||||
let error = (created == 0).then(io::Error::last_os_error);
|
||||
drop(revert);
|
||||
if let Some(error) = error {
|
||||
return Err(error);
|
||||
}
|
||||
let process = unsafe { OwnedHandle::from_raw_handle(information.hProcess) };
|
||||
let thread = unsafe { OwnedHandle::from_raw_handle(information.hThread) };
|
||||
if unsafe { AssignProcessToJobObject(job.as_raw_handle(), process.as_raw_handle()) } == 0 {
|
||||
let error = io::Error::last_os_error();
|
||||
// The suspended child is not owned by the job on this failure path.
|
||||
unsafe {
|
||||
TerminateProcess(process.as_raw_handle(), 1);
|
||||
WaitForSingleObject(process.as_raw_handle(), 5000);
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
let child = Self {
|
||||
process,
|
||||
job: Some(job),
|
||||
pid: information.dwProcessId,
|
||||
};
|
||||
if unsafe { ResumeThread(thread.as_raw_handle()) } == u32::MAX {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
Ok(child)
|
||||
}
|
||||
pub fn id(&self) -> u32 {
|
||||
self.pid
|
||||
}
|
||||
pub fn has_exited(&self) -> io::Result<bool> {
|
||||
match unsafe { WaitForSingleObject(self.process.as_raw_handle(), 0) } {
|
||||
WAIT_OBJECT_0 => Ok(true),
|
||||
WAIT_TIMEOUT => Ok(false),
|
||||
_ => Err(io::Error::last_os_error()),
|
||||
}
|
||||
}
|
||||
pub fn stop(&mut self) -> io::Result<()> {
|
||||
if self.job.take().is_none() {
|
||||
return Ok(());
|
||||
}
|
||||
match unsafe { WaitForSingleObject(self.process.as_raw_handle(), 5000) } {
|
||||
WAIT_OBJECT_0 => Ok(()),
|
||||
WAIT_TIMEOUT => Err(io::Error::new(
|
||||
io::ErrorKind::TimedOut,
|
||||
"Windows worker did not terminate",
|
||||
)),
|
||||
_ => Err(io::Error::last_os_error()),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Drop for UserProcess {
|
||||
fn drop(&mut self) {
|
||||
if let Err(error) = self.stop() {
|
||||
log::warn!("Could not stop Windows worker: {error}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use windows_sys::Win32::{Foundation::LocalFree, UI::Shell::CommandLineToArgvW};
|
||||
#[test]
|
||||
fn command_line_round_trips_through_windows_parser() {
|
||||
let program: Vec<u16> = r"C:\Program Files\GP Connect\gpgui-nsh.exe".encode_utf16().collect();
|
||||
let arguments = [
|
||||
"proxy-worker",
|
||||
"",
|
||||
"space value",
|
||||
"quoted\"value",
|
||||
"two\\\\\"quotes",
|
||||
"trailing\\",
|
||||
"雪",
|
||||
"&|<>",
|
||||
]
|
||||
.map(String::from);
|
||||
let command = command_line(&program, &arguments).unwrap();
|
||||
let mut count = 0;
|
||||
unsafe {
|
||||
let parsed = CommandLineToArgvW(command.as_ptr(), &mut count);
|
||||
assert!(!parsed.is_null());
|
||||
let result = std::slice::from_raw_parts(parsed, count as usize)
|
||||
.iter()
|
||||
.map(|&value| {
|
||||
let mut length = 0;
|
||||
while *value.add(length) != 0 {
|
||||
length += 1;
|
||||
}
|
||||
String::from_utf16_lossy(std::slice::from_raw_parts(value, length))
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
LocalFree(parsed.cast());
|
||||
assert_eq!(result[0], String::from_utf16_lossy(&program));
|
||||
assert_eq!(result[1..], arguments);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -187,19 +187,28 @@ mod tests {
|
||||
|
||||
#[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));
|
||||
use crate::device_anchor::AnchorSource;
|
||||
|
||||
for (source, wire_source) in [
|
||||
(AnchorSource::UnixMac, 1),
|
||||
(AnchorSource::UnixRandom, 2),
|
||||
(AnchorSource::MacosIokit, 3),
|
||||
(AnchorSource::WindowsSmbios, 4),
|
||||
] {
|
||||
let anchor = DeviceAnchor {
|
||||
hardware_id: general_purpose::URL_SAFE_NO_PAD.encode([1_u8; 32]),
|
||||
source,
|
||||
};
|
||||
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"], wire_source);
|
||||
let decoded = SessionCredential::decode_frame(&frame).unwrap();
|
||||
assert_eq!(decoded.device_anchor(), Some(&anchor));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -209,7 +218,7 @@ mod tests {
|
||||
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] {
|
||||
for source in [0, u8::MAX] {
|
||||
payload["device_anchor"] = serde_json::json!({
|
||||
"hardware_id": hardware_id,
|
||||
"source": source
|
||||
|
||||
@@ -11,6 +11,8 @@ pub use message::{ClientMessage, ServerMessage, ServiceRejection, ServiceResult}
|
||||
pub use noise::{NoiseInitiator, NoiseResponder, NoiseTransport};
|
||||
|
||||
pub const MAX_CREDENTIAL_FRAME: usize = 512;
|
||||
/// First request read before a Windows service captures its pipe client's token.
|
||||
pub const WINDOWS_ADMISSION_REQUEST: [u8; 4] = *b"GPC1";
|
||||
pub const MAX_PRELUDE: usize = 256;
|
||||
pub const MAX_PRODUCT_VERSION: usize = 64;
|
||||
pub const HIP_PROTOCOL_VERSION: u16 = 1;
|
||||
|
||||
@@ -29,6 +29,11 @@ use linux as platform;
|
||||
#[cfg(target_os = "macos")]
|
||||
use macos as platform;
|
||||
|
||||
#[cfg(windows)]
|
||||
mod windows;
|
||||
#[cfg(windows)]
|
||||
use windows as platform;
|
||||
|
||||
mod binding;
|
||||
use super::detection;
|
||||
pub mod native;
|
||||
@@ -475,6 +480,7 @@ fn snapshot(interfaces: &[Interface], control: &dyn CollectionControl) -> anyhow
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn command(name: &str, args: &[&str], control: &dyn CollectionControl) -> anyhow::Result<String> {
|
||||
let output = CollectorCommands::new(control)
|
||||
.run(name, args)?
|
||||
|
||||
@@ -0,0 +1,148 @@
|
||||
//! Windows network identity from IP Helper and adapter DNS configuration.
|
||||
use super::*;
|
||||
use std::os::windows::io::AsRawSocket;
|
||||
use windows_sys::Win32::{
|
||||
NetworkManagement::IpHelper::{
|
||||
DNS_INTERFACE_SETTINGS, DNS_INTERFACE_SETTINGS_VERSION1, FreeInterfaceDnsSettings, FreeMibTable,
|
||||
GetInterfaceDnsSettings, GetIpForwardTable2,
|
||||
},
|
||||
Networking::WinSock::{
|
||||
AF_INET, AF_INET6, AF_UNSPEC, IP_UNICAST_IF, IPPROTO_IP, IPPROTO_IPV6, IPV6_UNICAST_IF, SOCKADDR_INET,
|
||||
SOCKET_ERROR, WSAGetLastError, setsockopt,
|
||||
},
|
||||
};
|
||||
|
||||
pub(super) fn scope_resolver_socket(
|
||||
socket: &tokio::net::UdpSocket,
|
||||
interface: &Interface,
|
||||
endpoint: SocketAddr,
|
||||
) -> anyhow::Result<()> {
|
||||
ensure!(interface.index != 0, "Resolver interface index is missing");
|
||||
// IP_UNICAST_IF uses network byte order; IPV6_UNICAST_IF uses host byte order.
|
||||
let (level, option, index) = if endpoint.is_ipv4() {
|
||||
(IPPROTO_IP, IP_UNICAST_IF, interface.index.to_be())
|
||||
} else {
|
||||
(IPPROTO_IPV6, IPV6_UNICAST_IF, interface.index)
|
||||
};
|
||||
let result = unsafe {
|
||||
setsockopt(
|
||||
socket.as_raw_socket() as usize,
|
||||
level,
|
||||
option,
|
||||
(&index as *const u32).cast(),
|
||||
std::mem::size_of::<u32>() as i32,
|
||||
)
|
||||
};
|
||||
if result == SOCKET_ERROR {
|
||||
return Err(io::Error::from_raw_os_error(unsafe { WSAGetLastError() }).into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn routes(control: &dyn CollectionControl) -> anyhow::Result<Vec<RouteContext>> {
|
||||
control.check()?;
|
||||
let mut table = std::ptr::null_mut();
|
||||
let status = unsafe { GetIpForwardTable2(AF_UNSPEC, &mut table) };
|
||||
if status != 0 {
|
||||
return Err(io::Error::from_raw_os_error(status as i32).into());
|
||||
}
|
||||
let interfaces = netdev::get_interfaces();
|
||||
let result = unsafe {
|
||||
let rows = std::slice::from_raw_parts((*table).Table.as_ptr(), (*table).NumEntries as usize);
|
||||
rows
|
||||
.iter()
|
||||
.filter_map(|row| {
|
||||
let destination = address(&row.DestinationPrefix.Prefix)?;
|
||||
let gateway = address(&row.NextHop)?;
|
||||
let interface = interfaces
|
||||
.iter()
|
||||
.find(|interface| interface.index == row.InterfaceIndex)?;
|
||||
Some(RouteContext {
|
||||
destination: format!("{destination}/{}", row.DestinationPrefix.PrefixLength),
|
||||
gateway: gateway.to_string(),
|
||||
interface: interface.name.clone(),
|
||||
table: "main".into(),
|
||||
metric: row.Metric.to_string(),
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
};
|
||||
unsafe {
|
||||
FreeMibTable(table.cast());
|
||||
}
|
||||
control.check()?;
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
unsafe fn address(address: &SOCKADDR_INET) -> Option<IpAddr> {
|
||||
unsafe {
|
||||
match address.si_family {
|
||||
AF_INET => Some(std::net::Ipv4Addr::from(address.Ipv4.sin_addr.S_un.S_addr.to_ne_bytes()).into()),
|
||||
AF_INET6 => Some(std::net::Ipv6Addr::from(address.Ipv6.sin6_addr.u.Byte).into()),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn resolvers(control: &dyn CollectionControl) -> anyhow::Result<Vec<ResolverContext>> {
|
||||
control.check()?;
|
||||
let mut resolvers = netdev::get_interfaces()
|
||||
.into_iter()
|
||||
.filter(|interface| !interface.dns_servers.is_empty())
|
||||
.map(|interface| {
|
||||
Ok(ResolverContext {
|
||||
interface: Some(interface.name.clone()),
|
||||
servers: interface.dns_servers.iter().map(ToString::to_string).collect(),
|
||||
domains: resolver_domains(&interface.name)?,
|
||||
})
|
||||
})
|
||||
.collect::<anyhow::Result<Vec<_>>>()?;
|
||||
resolvers.sort();
|
||||
control.check()?;
|
||||
Ok(resolvers)
|
||||
}
|
||||
|
||||
fn resolver_domains(interface: &str) -> anyhow::Result<Vec<String>> {
|
||||
let id = uuid::Uuid::parse_str(interface.trim_matches(['{', '}']))?;
|
||||
let (data1, data2, data3, data4) = id.as_fields();
|
||||
let guid = windows_sys::core::GUID {
|
||||
data1,
|
||||
data2,
|
||||
data3,
|
||||
data4: *data4,
|
||||
};
|
||||
let mut settings = DNS_INTERFACE_SETTINGS {
|
||||
Version: DNS_INTERFACE_SETTINGS_VERSION1,
|
||||
..Default::default()
|
||||
};
|
||||
let status = unsafe { GetInterfaceDnsSettings(guid, &mut settings) };
|
||||
if status != 0 {
|
||||
return Err(io::Error::from_raw_os_error(status as i32).into());
|
||||
}
|
||||
let mut domains = Vec::new();
|
||||
for pointer in [settings.Domain, settings.SearchList] {
|
||||
if pointer.is_null() {
|
||||
continue;
|
||||
}
|
||||
let text = unsafe {
|
||||
let mut length = 0;
|
||||
while *pointer.add(length) != 0 {
|
||||
length += 1;
|
||||
}
|
||||
String::from_utf16_lossy(std::slice::from_raw_parts(pointer, length))
|
||||
};
|
||||
for domain in text
|
||||
.split(|ch: char| ch == ',' || ch.is_whitespace())
|
||||
.filter(|domain| !domain.is_empty())
|
||||
{
|
||||
let domain = domain.to_ascii_lowercase();
|
||||
if !domains.contains(&domain) {
|
||||
domains.push(domain);
|
||||
}
|
||||
}
|
||||
}
|
||||
unsafe {
|
||||
FreeInterfaceDnsSettings(&mut settings);
|
||||
}
|
||||
Ok(domains)
|
||||
}
|
||||
@@ -45,7 +45,7 @@ fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) ->
|
||||
Ok(builder.interface(binding.interface()))
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "freebsd", target_os = "openbsd"))]
|
||||
#[cfg(any(target_os = "freebsd", target_os = "openbsd", windows))]
|
||||
fn bind_interface(builder: reqwest::ClientBuilder, binding: &GatewayBinding) -> anyhow::Result<reqwest::ClientBuilder> {
|
||||
if let std::net::SocketAddr::V6(source) = binding.source() {
|
||||
anyhow::ensure!(
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use common::constants::GP_SERVICE_LOCK_FILE;
|
||||
use common::paths::service_lock_file;
|
||||
use thiserror::Error;
|
||||
use tokio::fs;
|
||||
|
||||
@@ -109,7 +109,7 @@ impl LockInfo {
|
||||
}
|
||||
|
||||
pub async fn gpservice_lock_info() -> Result<LockInfo, LockFileError> {
|
||||
gpservice_lock_info_at(GP_SERVICE_LOCK_FILE).await
|
||||
gpservice_lock_info_at(service_lock_file()).await
|
||||
}
|
||||
|
||||
pub async fn gpservice_lock_info_at(path: impl AsRef<Path>) -> Result<LockInfo, LockFileError> {
|
||||
|
||||
@@ -13,6 +13,9 @@ pub async fn shutdown_signal() {
|
||||
.await;
|
||||
};
|
||||
|
||||
#[cfg(not(unix))]
|
||||
let terminate = std::future::pending::<()>();
|
||||
|
||||
tokio::select! {
|
||||
_ = ctrl_c => {},
|
||||
_ = terminate => {},
|
||||
|
||||
@@ -0,0 +1,176 @@
|
||||
//! Windows user identity and private local IPC.
|
||||
use std::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle, FromRawHandle, OwnedHandle};
|
||||
use std::{io, ptr};
|
||||
mod pipes;
|
||||
pub use pipes::{PacketPipe, connect_service_admission, connect_service_worker, create_service_admission_pipe};
|
||||
use tokio::net::windows::named_pipe::NamedPipeServer;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{CloseHandle, LocalFree},
|
||||
Security::{Authorization::ConvertSidToStringSidW, GetTokenInformation, TOKEN_QUERY, TOKEN_USER, TokenUser},
|
||||
System::Threading::{GetCurrentProcess, OpenProcess, OpenProcessToken, PROCESS_QUERY_LIMITED_INFORMATION},
|
||||
};
|
||||
|
||||
pub fn current_user_sid() -> io::Result<String> {
|
||||
unsafe {
|
||||
let mut token = ptr::null_mut();
|
||||
if OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let result = token_user_sid(token);
|
||||
CloseHandle(token);
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
/// An authenticated pipe client's primary token, retained for its user-session worker.
|
||||
/// Windows user identity is a SID and token; it is never represented as a Unix UID.
|
||||
pub struct PipeClientIdentity {
|
||||
sid: String,
|
||||
token: OwnedHandle,
|
||||
}
|
||||
|
||||
impl PipeClientIdentity {
|
||||
pub fn sid(&self) -> &str {
|
||||
&self.sid
|
||||
}
|
||||
|
||||
pub fn primary_token(&self) -> BorrowedHandle<'_> {
|
||||
self.token.as_handle()
|
||||
}
|
||||
|
||||
/// Call after reading the client's admission request. Impersonation stays on
|
||||
/// this thread and ends before returning; no asynchronous work can run in it.
|
||||
pub fn from_pipe(pipe: &NamedPipeServer) -> io::Result<Self> {
|
||||
use windows_sys::Win32::{
|
||||
Security::{
|
||||
DuplicateTokenEx, RevertToSelf, SecurityImpersonation, TOKEN_ASSIGN_PRIMARY, TOKEN_DUPLICATE, TokenPrimary,
|
||||
},
|
||||
System::{
|
||||
Pipes::ImpersonateNamedPipeClient,
|
||||
Threading::{GetCurrentThread, OpenThreadToken},
|
||||
},
|
||||
};
|
||||
struct Revert;
|
||||
impl Drop for Revert {
|
||||
fn drop(&mut self) {
|
||||
// Continuing a service thread as its client would corrupt its privilege
|
||||
// boundary. Windows documents terminating if RevertToSelf fails.
|
||||
if unsafe { RevertToSelf() } == 0 {
|
||||
std::process::abort();
|
||||
}
|
||||
}
|
||||
}
|
||||
unsafe {
|
||||
if ImpersonateNamedPipeClient(pipe.as_raw_handle()) == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let _revert = Revert;
|
||||
let mut token = ptr::null_mut();
|
||||
if OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_DUPLICATE, 1, &mut token) == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let token = OwnedHandle::from_raw_handle(token);
|
||||
let sid = token_user_sid(token.as_raw_handle())?;
|
||||
let mut primary = ptr::null_mut();
|
||||
if DuplicateTokenEx(
|
||||
token.as_raw_handle(),
|
||||
TOKEN_QUERY | TOKEN_DUPLICATE | TOKEN_ASSIGN_PRIMARY,
|
||||
ptr::null(),
|
||||
SecurityImpersonation,
|
||||
TokenPrimary,
|
||||
&mut primary,
|
||||
) == 0
|
||||
{
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
Ok(Self {
|
||||
sid,
|
||||
token: OwnedHandle::from_raw_handle(primary),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolve a local IPC peer from its OS process token.
|
||||
pub fn process_user_sid(pid: u32) -> io::Result<String> {
|
||||
unsafe {
|
||||
let process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid);
|
||||
if process.is_null() {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let mut token = ptr::null_mut();
|
||||
if OpenProcessToken(process, TOKEN_QUERY, &mut token) == 0 {
|
||||
let error = io::Error::last_os_error();
|
||||
CloseHandle(process);
|
||||
return Err(error);
|
||||
}
|
||||
CloseHandle(process);
|
||||
let result = token_user_sid(token);
|
||||
CloseHandle(token);
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn token_user_sid(token: windows_sys::Win32::Foundation::HANDLE) -> io::Result<String> {
|
||||
unsafe {
|
||||
let mut length = 0;
|
||||
GetTokenInformation(token, TokenUser, ptr::null_mut(), 0, &mut length);
|
||||
// TOKEN_USER contains pointers; retain pointer alignment in its backing allocation.
|
||||
let mut buffer = vec![0usize; (length as usize).div_ceil(std::mem::size_of::<usize>())];
|
||||
if GetTokenInformation(token, TokenUser, buffer.as_mut_ptr().cast(), length, &mut length) == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let user = &*buffer.as_ptr().cast::<TOKEN_USER>();
|
||||
let mut text = ptr::null_mut();
|
||||
if ConvertSidToStringSidW(user.User.Sid, &mut text) == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let mut length = 0;
|
||||
while *text.add(length) != 0 {
|
||||
length += 1;
|
||||
}
|
||||
let sid = String::from_utf16_lossy(std::slice::from_raw_parts(text, length));
|
||||
LocalFree(text.cast());
|
||||
Ok(sid)
|
||||
}
|
||||
}
|
||||
|
||||
/// Only the owning user and SYSTEM can access authentication callbacks.
|
||||
pub fn create_user_pipe(name: &str, first_instance: bool) -> io::Result<NamedPipeServer> {
|
||||
pipes::user_pipe(¤t_user_sid()?, name, first_instance)
|
||||
}
|
||||
|
||||
/// Query a registered service without requiring access to its SYSTEM process token.
|
||||
pub fn service_process_id(name: &str) -> io::Result<u32> {
|
||||
use windows_sys::Win32::System::Services::*;
|
||||
let name: Vec<u16> = name.encode_utf16().chain(Some(0)).collect();
|
||||
unsafe {
|
||||
let manager = OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT);
|
||||
if manager.is_null() {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let service = OpenServiceW(manager, name.as_ptr(), SERVICE_QUERY_STATUS);
|
||||
if service.is_null() {
|
||||
let error = io::Error::last_os_error();
|
||||
CloseServiceHandle(manager);
|
||||
return Err(error);
|
||||
}
|
||||
let mut status = SERVICE_STATUS_PROCESS::default();
|
||||
let mut length = 0;
|
||||
let success = QueryServiceStatusEx(
|
||||
service,
|
||||
SC_STATUS_PROCESS_INFO,
|
||||
(&mut status as *mut SERVICE_STATUS_PROCESS).cast(),
|
||||
std::mem::size_of_val(&status) as u32,
|
||||
&mut length,
|
||||
);
|
||||
let result = if success == 0 {
|
||||
Err(io::Error::last_os_error())
|
||||
} else {
|
||||
Ok(status.dwProcessId)
|
||||
};
|
||||
CloseServiceHandle(service);
|
||||
CloseServiceHandle(manager);
|
||||
result
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
//! Local service admission and worker pipes with explicit user access.
|
||||
use super::PipeClientIdentity;
|
||||
use std::{
|
||||
fs::OpenOptions,
|
||||
io,
|
||||
os::windows::{
|
||||
fs::OpenOptionsExt,
|
||||
io::{AsRawHandle, FromRawHandle, IntoRawHandle, OwnedHandle},
|
||||
},
|
||||
ptr,
|
||||
time::Duration,
|
||||
};
|
||||
use tokio::net::windows::named_pipe::{NamedPipeClient, NamedPipeServer, ServerOptions};
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{ERROR_IO_PENDING, ERROR_PIPE_CONNECTED, INVALID_HANDLE_VALUE, LocalFree, WAIT_OBJECT_0, WAIT_TIMEOUT},
|
||||
Security::{Authorization::ConvertStringSecurityDescriptorToSecurityDescriptorW, SECURITY_ATTRIBUTES},
|
||||
Storage::FileSystem::*,
|
||||
System::{
|
||||
IO::{CancelIoEx, GetOverlappedResult, OVERLAPPED},
|
||||
Pipes::*,
|
||||
Threading::{CreateEventW, WaitForSingleObject},
|
||||
},
|
||||
};
|
||||
|
||||
// Generic write also grants FILE_CREATE_PIPE_INSTANCE. Clients receive only
|
||||
// data/metadata access; creating another instance remains SYSTEM-only.
|
||||
const CLIENT_ACCESS: u32 = FILE_GENERIC_READ | FILE_WRITE_DATA | FILE_WRITE_EA | FILE_WRITE_ATTRIBUTES;
|
||||
fn wide(value: &str) -> Vec<u16> {
|
||||
value.encode_utf16().chain(Some(0)).collect()
|
||||
}
|
||||
fn with_security<T>(sddl: &str, operation: impl FnOnce(&SECURITY_ATTRIBUTES) -> io::Result<T>) -> io::Result<T> {
|
||||
struct Descriptor(*mut std::ffi::c_void);
|
||||
impl Drop for Descriptor {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
LocalFree(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut pointer = ptr::null_mut();
|
||||
if unsafe {
|
||||
ConvertStringSecurityDescriptorToSecurityDescriptorW(wide(sddl).as_ptr(), 1, &mut pointer, ptr::null_mut())
|
||||
} == 0
|
||||
{
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let descriptor = Descriptor(pointer);
|
||||
operation(&SECURITY_ATTRIBUTES {
|
||||
nLength: std::mem::size_of::<SECURITY_ATTRIBUTES>() as u32,
|
||||
lpSecurityDescriptor: descriptor.0,
|
||||
bInheritHandle: 0,
|
||||
})
|
||||
}
|
||||
fn server(sddl: &str, name: &str, first: bool) -> io::Result<NamedPipeServer> {
|
||||
with_security(sddl, |attributes| unsafe {
|
||||
ServerOptions::new()
|
||||
.first_pipe_instance(first)
|
||||
.reject_remote_clients(true)
|
||||
.create_with_security_attributes_raw(name, (attributes as *const SECURITY_ATTRIBUTES).cast_mut().cast())
|
||||
})
|
||||
}
|
||||
pub(super) fn user_pipe(sid: &str, name: &str, first: bool) -> io::Result<NamedPipeServer> {
|
||||
server(&format!("D:P(A;;GA;;;SY)(A;;GA;;;{sid})"), name, first)
|
||||
}
|
||||
pub fn create_service_admission_pipe(first: bool) -> io::Result<NamedPipeServer> {
|
||||
server(
|
||||
&format!("D:P(A;;GA;;;SY)(A;;0x{CLIENT_ACCESS:x};;;AU)"),
|
||||
common::paths::SERVICE_PIPE,
|
||||
first,
|
||||
)
|
||||
}
|
||||
fn client(name: &str, message: bool, impersonation: bool) -> io::Result<NamedPipeClient> {
|
||||
let file = OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.access_mode(CLIENT_ACCESS)
|
||||
.custom_flags(FILE_FLAG_OVERLAPPED)
|
||||
.security_qos_flags(if impersonation {
|
||||
SECURITY_IMPERSONATION
|
||||
} else {
|
||||
SECURITY_IDENTIFICATION
|
||||
})
|
||||
.open(name)?;
|
||||
let pipe = unsafe { NamedPipeClient::from_raw_handle(file.into_raw_handle()) }?;
|
||||
let mut pid = 0;
|
||||
if unsafe { GetNamedPipeServerProcessId(pipe.as_raw_handle(), &mut pid) } == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
if pid == 0 || pid != super::service_process_id(common::paths::SERVICE_NAME)? {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::PermissionDenied,
|
||||
"Pipe does not belong to the registered VPN service",
|
||||
));
|
||||
}
|
||||
if message {
|
||||
let mode = PIPE_READMODE_MESSAGE;
|
||||
if unsafe { SetNamedPipeHandleState(pipe.as_raw_handle(), &mode, ptr::null(), ptr::null()) } == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
}
|
||||
Ok(pipe)
|
||||
}
|
||||
/// Verify the service before the first request permits it to impersonate this user.
|
||||
pub fn connect_service_admission() -> io::Result<NamedPipeClient> {
|
||||
client(common::paths::SERVICE_PIPE, false, true)
|
||||
}
|
||||
pub fn connect_service_worker(name: &str, message: bool) -> io::Result<NamedPipeClient> {
|
||||
client(name, message, false)
|
||||
}
|
||||
|
||||
impl PipeClientIdentity {
|
||||
pub fn create_control_pipe(&self, name: &str) -> io::Result<NamedPipeServer> {
|
||||
server(
|
||||
&format!("D:P(A;;GA;;;SY)(A;;0x{CLIENT_ACCESS:x};;;{})", self.sid()),
|
||||
name,
|
||||
true,
|
||||
)
|
||||
}
|
||||
pub fn create_packet_pipe(&self, name: &str) -> io::Result<PacketPipe> {
|
||||
let name = wide(name);
|
||||
with_security(
|
||||
&format!("D:P(A;;GA;;;SY)(A;;0x{CLIENT_ACCESS:x};;;{})", self.sid()),
|
||||
|attributes| {
|
||||
let handle = unsafe {
|
||||
CreateNamedPipeW(
|
||||
name.as_ptr(),
|
||||
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE,
|
||||
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_REJECT_REMOTE_CLIENTS,
|
||||
1,
|
||||
256 * 1024,
|
||||
256 * 1024,
|
||||
0,
|
||||
attributes,
|
||||
)
|
||||
};
|
||||
if handle == INVALID_HANDLE_VALUE {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
Ok(PacketPipe(unsafe { OwnedHandle::from_raw_handle(handle) }))
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
/// Raw Win32 overlapped I/O, deliberately never registered with Tokio/Mio IOCP.
|
||||
pub struct PacketPipe(OwnedHandle);
|
||||
impl PacketPipe {
|
||||
pub fn connect(&mut self, expected_pid: u32, timeout: Duration) -> io::Result<()> {
|
||||
let event = unsafe { CreateEventW(ptr::null(), 1, 0, ptr::null()) };
|
||||
if event.is_null() {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let event = unsafe { OwnedHandle::from_raw_handle(event) };
|
||||
let mut overlap = OVERLAPPED {
|
||||
hEvent: event.as_raw_handle(),
|
||||
..Default::default()
|
||||
};
|
||||
if unsafe { ConnectNamedPipe(self.0.as_raw_handle(), &mut overlap) } == 0 {
|
||||
let error = io::Error::last_os_error();
|
||||
match error.raw_os_error().map(|code| code as u32) {
|
||||
Some(ERROR_PIPE_CONNECTED) => {}
|
||||
Some(ERROR_IO_PENDING) => {
|
||||
let status = unsafe {
|
||||
WaitForSingleObject(
|
||||
event.as_raw_handle(),
|
||||
timeout.as_millis().min(u32::MAX as u128 - 1) as u32,
|
||||
)
|
||||
};
|
||||
let mut bytes = 0;
|
||||
if status != WAIT_OBJECT_0 {
|
||||
// Complete cancellation before OVERLAPPED/event storage is released.
|
||||
unsafe {
|
||||
CancelIoEx(self.0.as_raw_handle(), &overlap);
|
||||
GetOverlappedResult(self.0.as_raw_handle(), &overlap, &mut bytes, 1);
|
||||
}
|
||||
if status == WAIT_TIMEOUT {
|
||||
return Err(io::Error::new(io::ErrorKind::TimedOut, "Packet worker did not connect"));
|
||||
}
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
if unsafe { GetOverlappedResult(self.0.as_raw_handle(), &overlap, &mut bytes, 0) } == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
}
|
||||
_ => return Err(error),
|
||||
}
|
||||
}
|
||||
let mut pid = 0;
|
||||
if unsafe { GetNamedPipeClientProcessId(self.0.as_raw_handle(), &mut pid) } == 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
if pid != expected_pid {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::PermissionDenied,
|
||||
"Unexpected packet pipe client",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn into_handle(self) -> OwnedHandle {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
#![cfg(windows)]
|
||||
|
||||
use gpapi::windows::{PipeClientIdentity, create_user_pipe, current_user_sid};
|
||||
use std::{io, os::windows::io::AsRawHandle, ptr, time::Duration};
|
||||
use tokio::{
|
||||
io::{AsyncReadExt, AsyncWriteExt},
|
||||
net::windows::named_pipe::ClientOptions,
|
||||
};
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{CloseHandle, ERROR_NO_TOKEN},
|
||||
Security::{GetTokenInformation, TOKEN_QUERY, TOKEN_TYPE, TokenPrimary, TokenType},
|
||||
Storage::FileSystem::{SECURITY_IDENTIFICATION, SECURITY_IMPERSONATION},
|
||||
System::Threading::{GetCurrentThread, OpenThreadToken},
|
||||
};
|
||||
|
||||
fn assert_reverted() {
|
||||
let mut token = ptr::null_mut();
|
||||
let success = unsafe { OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, 1, &mut token) };
|
||||
if success != 0 {
|
||||
unsafe {
|
||||
CloseHandle(token);
|
||||
}
|
||||
panic!("The service thread still impersonates its client");
|
||||
}
|
||||
assert_eq!(io::Error::last_os_error().raw_os_error(), Some(ERROR_NO_TOKEN as i32));
|
||||
}
|
||||
|
||||
async fn admission(qos: u32) -> io::Result<PipeClientIdentity> {
|
||||
let path = format!(r"\\.\pipe\GPConnect.IdentityTest.{}", uuid::Uuid::new_v4());
|
||||
let mut pipe = create_user_pipe(&path, true)?;
|
||||
let client = tokio::spawn(async move {
|
||||
let mut pipe = ClientOptions::new().security_qos_flags(qos).open(path).unwrap();
|
||||
pipe.write_all(b"admit").await.unwrap();
|
||||
let mut response = [0];
|
||||
pipe.read_exact(&mut response).await.unwrap();
|
||||
// Confirm delivery before the server disconnects its Windows pipe.
|
||||
pipe.write_all(b"ack").await.unwrap();
|
||||
});
|
||||
pipe.connect().await?;
|
||||
let mut request = [0; 5];
|
||||
pipe.read_exact(&mut request).await?;
|
||||
assert_eq!(&request, b"admit");
|
||||
let identity = PipeClientIdentity::from_pipe(&pipe);
|
||||
assert_reverted();
|
||||
pipe.write_all(&[1]).await?;
|
||||
let mut ack = [0; 3];
|
||||
pipe.read_exact(&mut ack).await?;
|
||||
assert_eq!(&ack, b"ack");
|
||||
client.await.unwrap();
|
||||
identity
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn captures_primary_token_and_reverts_before_returning() {
|
||||
let identity = tokio::time::timeout(Duration::from_secs(5), admission(SECURITY_IMPERSONATION))
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(identity.sid(), current_user_sid().unwrap());
|
||||
let mut kind: TOKEN_TYPE = 0;
|
||||
let mut length = 0;
|
||||
assert_ne!(
|
||||
unsafe {
|
||||
GetTokenInformation(
|
||||
identity.primary_token().as_raw_handle(),
|
||||
TokenType,
|
||||
(&mut kind as *mut TOKEN_TYPE).cast(),
|
||||
std::mem::size_of_val(&kind) as u32,
|
||||
&mut length,
|
||||
)
|
||||
},
|
||||
0
|
||||
);
|
||||
assert_eq!(kind, TokenPrimary);
|
||||
assert_reverted();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn identification_only_client_cannot_supply_a_worker_token() {
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_secs(5), admission(SECURITY_IDENTIFICATION))
|
||||
.await
|
||||
.unwrap()
|
||||
.is_err()
|
||||
);
|
||||
assert_reverted();
|
||||
}
|
||||
@@ -15,5 +15,7 @@ serde.workspace = true
|
||||
serde_json.workspace = true
|
||||
serde_urlencoded.workspace = true
|
||||
uuid = { workspace = true, features = ["v5"] }
|
||||
uzers.workspace = true
|
||||
xmltree.workspace = true
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
uzers.workspace = true
|
||||
@@ -570,11 +570,14 @@ fn detect_ufw(commands: &CollectorCommands<'_>) -> io::Result<Option<UfwInfo>> {
|
||||
let Some(ufw) = commands.resolve("ufw") else {
|
||||
return Ok(None);
|
||||
};
|
||||
#[cfg(unix)]
|
||||
let output = if uzers::get_effective_uid() == 0 {
|
||||
commands.run_path(&ufw, &["status"])?
|
||||
} else {
|
||||
commands.run("sudo", &["-n", &ufw.to_string_lossy(), "status"])?
|
||||
};
|
||||
#[cfg(windows)]
|
||||
let output = commands.run_path(&ufw, &["status"])?;
|
||||
let Some(output) = output.filter(|output| output.status.success()) else {
|
||||
return Ok(None);
|
||||
};
|
||||
|
||||
@@ -5,5 +5,21 @@ version.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[target.'cfg(target_os = "macos")'.dependencies]
|
||||
[target.'cfg(any(target_os = "macos", windows))'.dependencies]
|
||||
log.workspace = true
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
ipnet = { version = "2", features = ["serde"] }
|
||||
base64.workspace = true
|
||||
serde_json.workspace = true
|
||||
serde.workspace = true
|
||||
winreg = "0.56"
|
||||
uuid = { workspace = true, features = ["v4"] }
|
||||
windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_NetworkManagement_IpHelper", "Win32_NetworkManagement_Ndis", "Win32_Networking_WinSock", "Win32_System_Threading"] }
|
||||
|
||||
[dev-dependencies]
|
||||
ipnet = "2"
|
||||
|
||||
[target.'cfg(windows)'.dev-dependencies]
|
||||
tempfile.workspace = true
|
||||
windows-sys = { version = "0.61", features = ["Win32_System_LibraryLoader"] }
|
||||
@@ -1,2 +1,7 @@
|
||||
#[cfg(target_os = "macos")]
|
||||
pub mod macos;
|
||||
#[cfg(windows)]
|
||||
pub mod windows;
|
||||
#[cfg(all(test, not(windows)))]
|
||||
#[path = "windows/configuration.rs"]
|
||||
mod windows_configuration;
|
||||
@@ -0,0 +1,249 @@
|
||||
//! Convert OpenConnect's normal configuration callback into a Windows network plan.
|
||||
use ipnet::IpNet;
|
||||
use std::{collections::HashMap, io, net::IpAddr};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(super) struct Configuration {
|
||||
pub interface: u32,
|
||||
pub gateway: IpAddr,
|
||||
pub addresses: Vec<IpNet>,
|
||||
pub mtu: Option<u32>,
|
||||
pub includes: Vec<IpNet>,
|
||||
pub excludes: Vec<IpNet>,
|
||||
pub servers: Vec<IpAddr>,
|
||||
pub domains: Vec<String>,
|
||||
pub split_dns: Vec<String>,
|
||||
}
|
||||
|
||||
fn invalid(message: impl Into<String>) -> io::Error {
|
||||
io::Error::new(io::ErrorKind::InvalidData, message.into())
|
||||
}
|
||||
impl Configuration {
|
||||
pub fn parse(environment: &[(String, Option<String>)]) -> io::Result<Self> {
|
||||
let values: HashMap<_, _> = environment
|
||||
.iter()
|
||||
.filter_map(|(key, value)| value.as_deref().map(|value| (key.as_str(), value)))
|
||||
.collect();
|
||||
let required = |key: &str| {
|
||||
values
|
||||
.get(key)
|
||||
.copied()
|
||||
.filter(|value| !value.is_empty())
|
||||
.ok_or_else(|| invalid(format!("Missing VPN configuration: {key}")))
|
||||
};
|
||||
let interface: u32 = required("TUNIDX")?
|
||||
.parse()
|
||||
.map_err(|_| invalid("Invalid VPN interface index"))?;
|
||||
if interface == 0 {
|
||||
return Err(invalid("VPN interface index is zero"));
|
||||
}
|
||||
let gateway = required("VPNGATEWAY")?
|
||||
.parse()
|
||||
.map_err(|_| invalid("Invalid VPN gateway address"))?;
|
||||
let mut addresses = Vec::new();
|
||||
if let Some(address) = values.get("INTERNAL_IP4_ADDRESS") {
|
||||
let prefix = values.get("INTERNAL_IP4_NETMASKLEN").copied().unwrap_or("32");
|
||||
let network: IpNet = format!("{address}/{prefix}")
|
||||
.parse()
|
||||
.map_err(|_| invalid("Invalid VPN IPv4 address or prefix"))?;
|
||||
if !matches!(network, IpNet::V4(_)) {
|
||||
return Err(invalid("VPN IPv4 address has the wrong family"));
|
||||
}
|
||||
addresses.push(network);
|
||||
}
|
||||
if let Some(address) = values.get("INTERNAL_IP6_ADDRESS") {
|
||||
let prefix = values
|
||||
.get("INTERNAL_IP6_NETMASK")
|
||||
.and_then(|value| value.rsplit_once('/'))
|
||||
.map(|(_, prefix)| prefix)
|
||||
.unwrap_or("128");
|
||||
let network: IpNet = format!("{address}/{prefix}")
|
||||
.parse()
|
||||
.map_err(|_| invalid("Invalid VPN IPv6 address or prefix"))?;
|
||||
if !matches!(network, IpNet::V6(_)) {
|
||||
return Err(invalid("VPN IPv6 address has the wrong family"));
|
||||
}
|
||||
addresses.push(network);
|
||||
}
|
||||
if addresses.is_empty() {
|
||||
return Err(invalid("The VPN did not assign an IP address"));
|
||||
}
|
||||
let mtu = values
|
||||
.get("INTERNAL_IP4_MTU")
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(|value| value.parse::<u32>().map_err(|_| invalid("Invalid VPN MTU")))
|
||||
.transpose()?
|
||||
.filter(|mtu| *mtu != 0);
|
||||
let mut includes = Vec::new();
|
||||
let mut excludes = Vec::new();
|
||||
for (family, prefix) in [(4, "CISCO_SPLIT"), (6, "CISCO_IPV6_SPLIT")] {
|
||||
if !addresses
|
||||
.iter()
|
||||
.any(|address| address.addr().is_ipv4() == (family == 4))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let included = routes(&values, &format!("{prefix}_INC"), family)?;
|
||||
if included.is_empty() {
|
||||
// Preserve the physical default route, using the two more-specific halves.
|
||||
let defaults: &[&str] = if family == 4 {
|
||||
&["0.0.0.0/1", "128.0.0.0/1"]
|
||||
} else {
|
||||
&["::/1", "8000::/1"]
|
||||
};
|
||||
includes.extend(defaults.iter().map(|route| route.parse::<IpNet>().unwrap()));
|
||||
} else {
|
||||
includes.extend(included);
|
||||
}
|
||||
excludes.extend(routes(&values, &format!("{prefix}_EXC"), family)?);
|
||||
}
|
||||
let mut servers = values
|
||||
.get("INTERNAL_IP4_DNS")
|
||||
.into_iter()
|
||||
.flat_map(|text| text.split_whitespace())
|
||||
.map(|address| address.parse().map_err(|_| invalid("Invalid VPN DNS server")))
|
||||
.collect::<io::Result<Vec<IpAddr>>>()?;
|
||||
let advertised_dns = !servers.is_empty();
|
||||
servers.retain(|server| {
|
||||
addresses
|
||||
.iter()
|
||||
.any(|address| address.addr().is_ipv4() == server.is_ipv4())
|
||||
});
|
||||
if advertised_dns && servers.is_empty() {
|
||||
return Err(invalid("No VPN DNS server matches an assigned address family"));
|
||||
}
|
||||
let domains = names(values.get("CISCO_DEF_DOMAIN").copied().unwrap_or(""));
|
||||
let split_dns = names(values.get("CISCO_SPLIT_DNS").copied().unwrap_or(""));
|
||||
Ok(Self {
|
||||
interface,
|
||||
gateway,
|
||||
addresses,
|
||||
mtu,
|
||||
includes,
|
||||
excludes,
|
||||
servers,
|
||||
domains,
|
||||
split_dns,
|
||||
})
|
||||
}
|
||||
}
|
||||
fn names(text: &str) -> Vec<String> {
|
||||
text
|
||||
.split(|ch: char| ch == ',' || ch.is_whitespace())
|
||||
.filter(|part| !part.is_empty())
|
||||
.map(str::to_owned)
|
||||
.collect()
|
||||
}
|
||||
fn routes(values: &HashMap<&str, &str>, key: &str, family: u8) -> io::Result<Vec<IpNet>> {
|
||||
let count = values
|
||||
.get(key)
|
||||
.map(|value| {
|
||||
value
|
||||
.parse::<u32>()
|
||||
.map_err(|_| invalid(format!("Invalid {key} count")))
|
||||
})
|
||||
.transpose()?
|
||||
.unwrap_or(0);
|
||||
(0..count)
|
||||
.map(|index| {
|
||||
let address = values
|
||||
.get(format!("{key}_{index}_ADDR").as_str())
|
||||
.ok_or_else(|| invalid(format!("Missing {key} address")))?;
|
||||
let prefix = values
|
||||
.get(format!("{key}_{index}_MASKLEN").as_str())
|
||||
.ok_or_else(|| invalid(format!("Missing {key} prefix")))?;
|
||||
let route: IpNet = format!("{address}/{prefix}")
|
||||
.parse()
|
||||
.map_err(|_| invalid(format!("Invalid {key} route")))?;
|
||||
if route.addr().is_ipv4() != (family == 4) {
|
||||
return Err(invalid(format!("Wrong {key} route family")));
|
||||
}
|
||||
Ok(route.trunc())
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
fn environment(extra: &[(&str, &str)]) -> Vec<(String, Option<String>)> {
|
||||
[
|
||||
("TUNIDX", "16"),
|
||||
("VPNGATEWAY", "198.51.100.1"),
|
||||
("INTERNAL_IP4_ADDRESS", "10.20.30.4"),
|
||||
]
|
||||
.into_iter()
|
||||
.chain(extra.iter().copied())
|
||||
.map(|(key, value)| (key.into(), Some(value.into())))
|
||||
.collect()
|
||||
}
|
||||
#[test]
|
||||
fn full_tunnel_keeps_assigned_addresses_and_routes_both_families() {
|
||||
let plan = Configuration::parse(&environment(&[
|
||||
("INTERNAL_IP4_NETMASKLEN", "24"),
|
||||
("INTERNAL_IP6_ADDRESS", "fd00::4"),
|
||||
("INTERNAL_IP6_NETMASK", "fd00::4/64"),
|
||||
("INTERNAL_IP4_MTU", "1406"),
|
||||
("INTERNAL_IP4_DNS", "10.20.30.1 fd00::1"),
|
||||
]))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
plan.addresses.iter().map(ToString::to_string).collect::<Vec<_>>(),
|
||||
["10.20.30.4/24", "fd00::4/64"]
|
||||
);
|
||||
assert_eq!(plan.includes.len(), 4);
|
||||
assert_eq!(plan.servers.len(), 2);
|
||||
assert_eq!(plan.mtu, Some(1406));
|
||||
assert_eq!(plan.interface, 16);
|
||||
assert_eq!(plan.gateway.to_string(), "198.51.100.1");
|
||||
}
|
||||
#[test]
|
||||
fn split_routes_and_dns_preserve_gateway_configuration() {
|
||||
let plan = Configuration::parse(&environment(&[
|
||||
("CISCO_SPLIT_INC", "1"),
|
||||
("CISCO_SPLIT_INC_0_ADDR", "172.16.5.9"),
|
||||
("CISCO_SPLIT_INC_0_MASKLEN", "16"),
|
||||
("CISCO_SPLIT_EXC", "1"),
|
||||
("CISCO_SPLIT_EXC_0_ADDR", "172.16.10.0"),
|
||||
("CISCO_SPLIT_EXC_0_MASKLEN", "24"),
|
||||
("CISCO_DEF_DOMAIN", "corp.example"),
|
||||
("CISCO_SPLIT_DNS", "corp.example, internal.example"),
|
||||
]))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
plan.includes.iter().map(ToString::to_string).collect::<Vec<_>>(),
|
||||
["172.16.0.0/16"]
|
||||
);
|
||||
assert_eq!(plan.excludes[0].to_string(), "172.16.10.0/24");
|
||||
assert_eq!(plan.domains, ["corp.example"]);
|
||||
assert_eq!(plan.split_dns, ["corp.example", "internal.example"]);
|
||||
}
|
||||
#[test]
|
||||
fn unassigned_address_family_does_not_install_routes_or_resolvers() {
|
||||
let plan = Configuration::parse(&environment(&[
|
||||
("CISCO_IPV6_SPLIT_INC", "1"),
|
||||
("CISCO_IPV6_SPLIT_INC_0_ADDR", "fd00::"),
|
||||
("CISCO_IPV6_SPLIT_INC_0_MASKLEN", "64"),
|
||||
("INTERNAL_IP4_DNS", "10.20.30.1 fd00::1"),
|
||||
]))
|
||||
.unwrap();
|
||||
assert!(plan.includes.iter().all(|route| route.addr().is_ipv4()));
|
||||
assert_eq!(
|
||||
plan.servers.iter().map(ToString::to_string).collect::<Vec<_>>(),
|
||||
["10.20.30.1"]
|
||||
);
|
||||
assert!(Configuration::parse(&environment(&[("INTERNAL_IP4_DNS", "fd00::1")])).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_network_data_is_rejected_before_changes() {
|
||||
for extra in [
|
||||
vec![("TUNIDX", "0")],
|
||||
vec![("INTERNAL_IP4_NETMASKLEN", "99")],
|
||||
vec![("INTERNAL_IP4_DNS", "not-an-address")],
|
||||
vec![("CISCO_SPLIT_INC", "1")],
|
||||
] {
|
||||
assert!(Configuration::parse(&environment(&extra)).is_err());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$request = [Console]::In.ReadToEnd() | ConvertFrom-Json
|
||||
switch ($request.operation) {
|
||||
'add' {
|
||||
Add-DnsClientNrptRule -Namespace ([string[]]$request.namespaces) -NameServers ([string[]]$request.servers) -Comment $request.tag | Out-Null
|
||||
}
|
||||
'remove' {
|
||||
Get-DnsClientNrptRule | Where-Object { $_.Comment -eq $request.tag } | ForEach-Object {
|
||||
Remove-DnsClientNrptRule -Name $_.Name -Force
|
||||
}
|
||||
}
|
||||
'clear-stale' {
|
||||
Get-DnsClientNrptRule | Where-Object { $_.Comment -like 'GPConnect:*' } | ForEach-Object {
|
||||
Remove-DnsClientNrptRule -Name $_.Name -Force
|
||||
}
|
||||
}
|
||||
default { throw 'Invalid DNS policy operation' }
|
||||
}
|
||||
@@ -0,0 +1,178 @@
|
||||
//! Adapter DNS settings and Windows name-resolution policy scoped to this connection.
|
||||
use super::configuration::Configuration;
|
||||
use base64::Engine;
|
||||
use serde_json::json;
|
||||
use std::{
|
||||
io::{self, Write},
|
||||
os::windows::process::CommandExt,
|
||||
process::{Command, Stdio},
|
||||
};
|
||||
use windows_sys::{
|
||||
Win32::{
|
||||
NetworkManagement::{IpHelper::*, Ndis::NET_LUID_LH},
|
||||
System::Threading::CREATE_NO_WINDOW,
|
||||
},
|
||||
core::GUID,
|
||||
};
|
||||
|
||||
struct Snapshot {
|
||||
domain: String,
|
||||
search: String,
|
||||
}
|
||||
pub(super) struct Installed {
|
||||
guid: GUID,
|
||||
snapshot: Option<Snapshot>,
|
||||
tag: Option<String>,
|
||||
}
|
||||
fn check(status: u32) -> io::Result<()> {
|
||||
if status == 0 {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(io::Error::from_raw_os_error(status as i32))
|
||||
}
|
||||
}
|
||||
fn wide(text: &str) -> Vec<u16> {
|
||||
text.encode_utf16().chain(Some(0)).collect()
|
||||
}
|
||||
unsafe fn string(pointer: *const u16) -> String {
|
||||
if pointer.is_null() {
|
||||
return String::new();
|
||||
}
|
||||
unsafe {
|
||||
let mut length = 0;
|
||||
while *pointer.add(length) != 0 {
|
||||
length += 1;
|
||||
}
|
||||
String::from_utf16_lossy(std::slice::from_raw_parts(pointer, length))
|
||||
}
|
||||
}
|
||||
impl Snapshot {
|
||||
fn capture(guid: GUID) -> io::Result<Self> {
|
||||
let mut settings = DNS_INTERFACE_SETTINGS {
|
||||
Version: DNS_INTERFACE_SETTINGS_VERSION1,
|
||||
..Default::default()
|
||||
};
|
||||
check(unsafe { GetInterfaceDnsSettings(guid, &mut settings) })?;
|
||||
let snapshot = unsafe {
|
||||
Self {
|
||||
domain: string(settings.Domain),
|
||||
search: string(settings.SearchList),
|
||||
}
|
||||
};
|
||||
unsafe {
|
||||
FreeInterfaceDnsSettings(&mut settings);
|
||||
}
|
||||
Ok(snapshot)
|
||||
}
|
||||
fn write(&self, guid: GUID) -> io::Result<()> {
|
||||
let (mut domain, mut search) = (wide(&self.domain), wide(&self.search));
|
||||
let settings = DNS_INTERFACE_SETTINGS {
|
||||
Version: DNS_INTERFACE_SETTINGS_VERSION1,
|
||||
Flags: (DNS_SETTING_DOMAIN | DNS_SETTING_SEARCHLIST) as u64,
|
||||
Domain: domain.as_mut_ptr(),
|
||||
SearchList: search.as_mut_ptr(),
|
||||
..Default::default()
|
||||
};
|
||||
check(unsafe { SetInterfaceDnsSettings(guid, &settings) })
|
||||
}
|
||||
}
|
||||
impl Installed {
|
||||
pub fn apply(configuration: &Configuration) -> io::Result<Self> {
|
||||
let mut luid = NET_LUID_LH::default();
|
||||
let mut guid = GUID::default();
|
||||
check(unsafe { ConvertInterfaceIndexToLuid(configuration.interface, &mut luid) })?;
|
||||
check(unsafe { ConvertInterfaceLuidToGuid(&luid, &mut guid) })?;
|
||||
let mut installed = Self {
|
||||
guid,
|
||||
snapshot: Some(Snapshot::capture(guid)?),
|
||||
tag: None,
|
||||
};
|
||||
Snapshot {
|
||||
domain: configuration.domains.first().cloned().unwrap_or_default(),
|
||||
search: configuration.domains.join(","),
|
||||
}
|
||||
.write(guid)?;
|
||||
// NRPT selects both IPv4 and IPv6 VPN resolvers. Split namespaces leave
|
||||
// unrelated DNS on the physical network; "." covers full-tunnel DNS.
|
||||
// Existing static/DHCP adapter nameserver configuration stays untouched.
|
||||
if !configuration.servers.is_empty() {
|
||||
let namespaces: Vec<String> = if configuration.split_dns.is_empty() {
|
||||
vec![".".into()]
|
||||
} else {
|
||||
configuration
|
||||
.split_dns
|
||||
.iter()
|
||||
.map(|domain| format!(".{}", domain.trim_matches('.')))
|
||||
.collect()
|
||||
};
|
||||
let tag = format!("GPConnect:{}", uuid::Uuid::new_v4());
|
||||
installed.tag = Some(tag.clone());
|
||||
policy(
|
||||
json!({"operation":"add", "tag":tag, "namespaces":namespaces, "servers":configuration.servers.iter().map(ToString::to_string).collect::<Vec<_>>()}),
|
||||
)?;
|
||||
}
|
||||
Ok(installed)
|
||||
}
|
||||
pub fn restore(&mut self) -> io::Result<()> {
|
||||
let mut failure = None;
|
||||
if let Some(tag) = self.tag.take() {
|
||||
if let Err(error) = policy(json!({"operation":"remove", "tag":tag})) {
|
||||
log::warn!("Could not remove VPN DNS policy: {error}");
|
||||
failure = Some(error);
|
||||
}
|
||||
}
|
||||
if let Some(snapshot) = self.snapshot.take() {
|
||||
if let Err(error) = snapshot.write(self.guid) {
|
||||
log::warn!("Could not restore VPN adapter DNS: {error}");
|
||||
if failure.is_none() {
|
||||
failure = Some(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
failure.map_or(Ok(()), Err)
|
||||
}
|
||||
}
|
||||
impl Drop for Installed {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.restore();
|
||||
}
|
||||
}
|
||||
|
||||
/// A crashed service cannot run Drop. Remove only GP Connect's tagged policies
|
||||
/// before accepting a new connection; adapter rows disappear with Wintun itself.
|
||||
pub(super) fn clear_stale_policies() -> io::Result<()> {
|
||||
policy(json!({"operation":"clear-stale"}))
|
||||
}
|
||||
fn policy(request: serde_json::Value) -> io::Result<()> {
|
||||
const SCRIPT: &str = include_str!("dns-policy.ps1");
|
||||
let encoded = base64::engine::general_purpose::STANDARD
|
||||
.encode(SCRIPT.encode_utf16().flat_map(u16::to_le_bytes).collect::<Vec<_>>());
|
||||
let root =
|
||||
std::env::var_os("SystemRoot").ok_or_else(|| io::Error::other("Windows system directory is unavailable"))?;
|
||||
let executable = std::path::PathBuf::from(root).join("System32/WindowsPowerShell/v1.0/powershell.exe");
|
||||
let mut child = Command::new(executable)
|
||||
.args(["-NoProfile", "-NonInteractive", "-EncodedCommand", &encoded])
|
||||
.creation_flags(CREATE_NO_WINDOW)
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::piped())
|
||||
.spawn()?;
|
||||
let input = child
|
||||
.stdin
|
||||
.take()
|
||||
.expect("stdin is piped")
|
||||
.write_all(request.to_string().as_bytes());
|
||||
if let Err(error) = input {
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return Err(error);
|
||||
}
|
||||
let output = child.wait_with_output()?;
|
||||
if !output.status.success() {
|
||||
return Err(io::Error::other(format!(
|
||||
"Windows DNS policy failed: {}",
|
||||
String::from_utf8_lossy(&output.stderr).trim()
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,317 @@
|
||||
//! Native IP Helper changes with ownership of only the rows this connection creates.
|
||||
use super::{
|
||||
configuration::Configuration,
|
||||
recovery::{Journal, Route},
|
||||
};
|
||||
use ipnet::IpNet;
|
||||
use std::{
|
||||
io,
|
||||
net::{IpAddr, Ipv4Addr, Ipv6Addr},
|
||||
ptr,
|
||||
};
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{ERROR_NOT_FOUND, ERROR_OBJECT_ALREADY_EXISTS},
|
||||
NetworkManagement::IpHelper::*,
|
||||
Networking::WinSock::*,
|
||||
};
|
||||
|
||||
struct InstalledRoute {
|
||||
row: MIB_IPFORWARD_ROW2,
|
||||
record: Option<String>,
|
||||
}
|
||||
pub(super) struct Installed {
|
||||
routes: Vec<InstalledRoute>,
|
||||
journal: Journal,
|
||||
addresses: Vec<MIB_UNICASTIPADDRESS_ROW>,
|
||||
interfaces: Vec<MIB_IPINTERFACE_ROW>,
|
||||
}
|
||||
fn check(status: u32) -> io::Result<()> {
|
||||
if status == 0 {
|
||||
Ok(())
|
||||
} else {
|
||||
Err(io::Error::from_raw_os_error(status as i32))
|
||||
}
|
||||
}
|
||||
fn socket_address(address: IpAddr) -> SOCKADDR_INET {
|
||||
let mut result = SOCKADDR_INET::default();
|
||||
match address {
|
||||
IpAddr::V4(address) => {
|
||||
result.Ipv4.sin_family = AF_INET;
|
||||
result.Ipv4.sin_addr.S_un.S_addr = u32::from_ne_bytes(address.octets());
|
||||
}
|
||||
IpAddr::V6(address) => {
|
||||
result.Ipv6.sin6_family = AF_INET6;
|
||||
result.Ipv6.sin6_addr.u.Byte = address.octets();
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
fn empty_address(ipv4: bool) -> SOCKADDR_INET {
|
||||
socket_address(if ipv4 {
|
||||
Ipv4Addr::UNSPECIFIED.into()
|
||||
} else {
|
||||
Ipv6Addr::UNSPECIFIED.into()
|
||||
})
|
||||
}
|
||||
fn route(prefix: IpNet, interface: u32) -> MIB_IPFORWARD_ROW2 {
|
||||
let mut storage = std::mem::MaybeUninit::<MIB_IPFORWARD_ROW2>::zeroed();
|
||||
// IP Helper initializes BOOLEAN fields to 0xff. They must contain canonical
|
||||
// Rust bool values before this storage can become an initialized Rust row.
|
||||
let mut row = unsafe {
|
||||
let pointer = storage.as_mut_ptr();
|
||||
InitializeIpForwardEntry(pointer);
|
||||
std::ptr::addr_of_mut!((*pointer).Loopback).write(false);
|
||||
std::ptr::addr_of_mut!((*pointer).AutoconfigureAddress).write(false);
|
||||
std::ptr::addr_of_mut!((*pointer).Publish).write(false);
|
||||
std::ptr::addr_of_mut!((*pointer).Immortal).write(true);
|
||||
storage.assume_init()
|
||||
};
|
||||
row.InterfaceIndex = interface;
|
||||
row.DestinationPrefix.Prefix = socket_address(prefix.network());
|
||||
row.DestinationPrefix.PrefixLength = prefix.prefix_len();
|
||||
row.NextHop = empty_address(prefix.addr().is_ipv4());
|
||||
row.SitePrefixLength = 0;
|
||||
row.Metric = 0;
|
||||
row.Protocol = MIB_IPPROTO_NETMGMT;
|
||||
row
|
||||
}
|
||||
fn physical_route(prefix: IpNet, tunnel: u32) -> io::Result<MIB_IPFORWARD_ROW2> {
|
||||
let destination = socket_address(prefix.addr());
|
||||
let mut existing = MIB_IPFORWARD_ROW2::default();
|
||||
let mut source = SOCKADDR_INET::default();
|
||||
check(unsafe { GetBestRoute2(ptr::null(), 0, ptr::null(), &destination, 0, &mut existing, &mut source) })?;
|
||||
if existing.InterfaceIndex == tunnel {
|
||||
return Err(io::Error::other(
|
||||
"The VPN gateway or exclusion resolves through the VPN adapter",
|
||||
));
|
||||
}
|
||||
let mut row = route(prefix, existing.InterfaceIndex);
|
||||
row.InterfaceLuid = existing.InterfaceLuid;
|
||||
row.NextHop = existing.NextHop;
|
||||
row.Metric = existing.Metric;
|
||||
Ok(row)
|
||||
}
|
||||
impl Installed {
|
||||
pub fn apply(configuration: &Configuration, recovery_key: &str) -> io::Result<Self> {
|
||||
// Resolve all physical paths before introducing any tunnel routes.
|
||||
let gateway = IpNet::new(
|
||||
configuration.gateway,
|
||||
if configuration.gateway.is_ipv4() { 32 } else { 128 },
|
||||
)
|
||||
.map_err(io::Error::other)?;
|
||||
let physical = std::iter::once(gateway)
|
||||
.chain(configuration.excludes.iter().copied())
|
||||
.map(|prefix| physical_route(prefix, configuration.interface))
|
||||
.collect::<io::Result<Vec<_>>>()?;
|
||||
let mut installed = Self {
|
||||
routes: Vec::new(),
|
||||
addresses: Vec::new(),
|
||||
interfaces: Vec::new(),
|
||||
journal: Journal::begin(recovery_key)?,
|
||||
};
|
||||
for row in physical {
|
||||
installed.add_route(row, true)?;
|
||||
}
|
||||
for family in [AF_INET, AF_INET6] {
|
||||
if !configuration
|
||||
.addresses
|
||||
.iter()
|
||||
.any(|address| address.addr().is_ipv4() == (family == AF_INET))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let mut row = MIB_IPINTERFACE_ROW {
|
||||
Family: family,
|
||||
InterfaceIndex: configuration.interface,
|
||||
..Default::default()
|
||||
};
|
||||
check(unsafe { GetIpInterfaceEntry(&mut row) })?;
|
||||
installed.interfaces.push(row);
|
||||
row.UseAutomaticMetric = false;
|
||||
row.Metric = 1;
|
||||
row.DadTransmits = 0;
|
||||
row.RouterDiscoveryBehavior = RouterDiscoveryDisabled;
|
||||
if let Some(mtu) = configuration.mtu {
|
||||
row.NlMtu = mtu;
|
||||
}
|
||||
if family == AF_INET {
|
||||
row.SitePrefixLength = 0;
|
||||
}
|
||||
check(unsafe { SetIpInterfaceEntry(&mut row) })?;
|
||||
}
|
||||
for address in &configuration.addresses {
|
||||
let mut row = MIB_UNICASTIPADDRESS_ROW::default();
|
||||
unsafe {
|
||||
InitializeUnicastIpAddressEntry(&mut row);
|
||||
}
|
||||
row.InterfaceIndex = configuration.interface;
|
||||
row.Address = socket_address(address.addr());
|
||||
row.OnLinkPrefixLength = address.prefix_len();
|
||||
row.PrefixOrigin = IpPrefixOriginManual;
|
||||
row.SuffixOrigin = IpSuffixOriginManual;
|
||||
row.DadState = IpDadStatePreferred;
|
||||
let status = unsafe { CreateUnicastIpAddressEntry(&row) };
|
||||
if status != ERROR_OBJECT_ALREADY_EXISTS {
|
||||
check(status)?;
|
||||
installed.addresses.push(row);
|
||||
}
|
||||
}
|
||||
for prefix in &configuration.includes {
|
||||
installed.add_route(route(*prefix, configuration.interface), false)?;
|
||||
}
|
||||
for server in &configuration.servers {
|
||||
if *server == configuration.gateway {
|
||||
continue;
|
||||
}
|
||||
let prefix = IpNet::new(*server, if server.is_ipv4() { 32 } else { 128 }).map_err(io::Error::other)?;
|
||||
installed.add_route(route(prefix, configuration.interface), false)?;
|
||||
}
|
||||
Ok(installed)
|
||||
}
|
||||
fn add_route(&mut self, row: MIB_IPFORWARD_ROW2, physical: bool) -> io::Result<()> {
|
||||
let status = unsafe { CreateIpForwardEntry2(&row) };
|
||||
if status != ERROR_OBJECT_ALREADY_EXISTS {
|
||||
check(status)?;
|
||||
// Retain rollback ownership even if writing the registry record fails.
|
||||
self.routes.push(InstalledRoute { row, record: None });
|
||||
if physical {
|
||||
let name = self.journal.record(&Route::from_row(&row)?)?;
|
||||
self.routes.last_mut().expect("route was just installed").record = Some(name);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
pub fn restore(&mut self) -> io::Result<()> {
|
||||
let mut failure = None;
|
||||
for route in self.routes.drain(..).rev() {
|
||||
match remove_owned_route(&route.row) {
|
||||
Ok(()) => {
|
||||
if let Some(name) = route.record {
|
||||
if let Err(error) = self.journal.forget(&name) {
|
||||
log::warn!("Could not clear Windows route ownership: {error}");
|
||||
if failure.is_none() {
|
||||
failure = Some(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Err(error) => {
|
||||
log::warn!("Could not remove owned Windows route: {error}");
|
||||
if failure.is_none() {
|
||||
failure = Some(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut record = |status| {
|
||||
if status != ERROR_NOT_FOUND && status != 0 {
|
||||
let error = io::Error::from_raw_os_error(status as i32);
|
||||
log::warn!("Could not restore VPN network configuration: {error}");
|
||||
if failure.is_none() {
|
||||
failure = Some(error);
|
||||
}
|
||||
}
|
||||
};
|
||||
for row in self.addresses.drain(..).rev() {
|
||||
record(unsafe { DeleteUnicastIpAddressEntry(&row) });
|
||||
}
|
||||
for original in self.interfaces.drain(..).rev() {
|
||||
let mut current = MIB_IPINTERFACE_ROW {
|
||||
Family: original.Family,
|
||||
InterfaceIndex: original.InterfaceIndex,
|
||||
..Default::default()
|
||||
};
|
||||
let status = unsafe { GetIpInterfaceEntry(&mut current) };
|
||||
if status != 0 {
|
||||
record(status);
|
||||
continue;
|
||||
}
|
||||
current.UseAutomaticMetric = original.UseAutomaticMetric;
|
||||
current.Metric = original.Metric;
|
||||
current.NlMtu = original.NlMtu;
|
||||
current.DadTransmits = original.DadTransmits;
|
||||
current.RouterDiscoveryBehavior = original.RouterDiscoveryBehavior;
|
||||
if current.Family == AF_INET {
|
||||
current.SitePrefixLength = 0;
|
||||
}
|
||||
record(unsafe { SetIpInterfaceEntry(&mut current) });
|
||||
}
|
||||
failure.map_or(Ok(()), Err)
|
||||
}
|
||||
}
|
||||
impl Drop for Installed {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.restore();
|
||||
}
|
||||
}
|
||||
|
||||
fn address(value: &SOCKADDR_INET) -> io::Result<IpAddr> {
|
||||
unsafe {
|
||||
match value.si_family {
|
||||
AF_INET => Ok(Ipv4Addr::from(value.Ipv4.sin_addr.S_un.S_addr.to_ne_bytes()).into()),
|
||||
AF_INET6 => Ok(Ipv6Addr::from(value.Ipv6.sin6_addr.u.Byte).into()),
|
||||
_ => Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
"Invalid route address family",
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
fn scope(value: &SOCKADDR_INET) -> u32 {
|
||||
unsafe {
|
||||
if value.si_family == AF_INET6 {
|
||||
value.Ipv6.Anonymous.sin6_scope_id
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Route {
|
||||
fn from_row(row: &MIB_IPFORWARD_ROW2) -> io::Result<Self> {
|
||||
Ok(Self {
|
||||
prefix: IpNet::new(
|
||||
address(&row.DestinationPrefix.Prefix)?,
|
||||
row.DestinationPrefix.PrefixLength,
|
||||
)
|
||||
.map_err(io::Error::other)?,
|
||||
next_hop: address(&row.NextHop)?,
|
||||
interface_luid: unsafe { row.InterfaceLuid.Value },
|
||||
metric: row.Metric,
|
||||
prefix_scope: scope(&row.DestinationPrefix.Prefix),
|
||||
next_hop_scope: scope(&row.NextHop),
|
||||
})
|
||||
}
|
||||
fn row(&self) -> io::Result<MIB_IPFORWARD_ROW2> {
|
||||
if self.interface_luid == 0 || self.prefix.addr().is_ipv4() != self.next_hop.is_ipv4() {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::InvalidData,
|
||||
"Invalid saved Windows route",
|
||||
));
|
||||
}
|
||||
let mut row = route(self.prefix, 0);
|
||||
row.InterfaceLuid.Value = self.interface_luid;
|
||||
row.Metric = self.metric;
|
||||
row.NextHop = socket_address(self.next_hop);
|
||||
if self.prefix.addr().is_ipv6() {
|
||||
row.DestinationPrefix.Prefix.Ipv6.Anonymous.sin6_scope_id = self.prefix_scope;
|
||||
row.NextHop.Ipv6.Anonymous.sin6_scope_id = self.next_hop_scope;
|
||||
}
|
||||
Ok(row)
|
||||
}
|
||||
}
|
||||
fn remove_owned_route(row: &MIB_IPFORWARD_ROW2) -> io::Result<()> {
|
||||
let mut current = *row;
|
||||
let status = unsafe { GetIpForwardEntry2(&mut current) };
|
||||
if status == ERROR_NOT_FOUND {
|
||||
return Ok(());
|
||||
}
|
||||
check(status)?;
|
||||
if current.Protocol != row.Protocol || current.Metric != row.Metric {
|
||||
log::warn!("Preserving a Windows route changed after VPN installation");
|
||||
return Ok(());
|
||||
}
|
||||
check(unsafe { DeleteIpForwardEntry2(¤t) })
|
||||
}
|
||||
pub(super) fn recover_route(saved: &Route) -> io::Result<()> {
|
||||
remove_owned_route(&saved.row()?)
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
//! Windows network installation driven by OpenConnect's normal configuration callback.
|
||||
mod configuration;
|
||||
mod dns;
|
||||
mod ip_helper;
|
||||
mod recovery;
|
||||
use configuration::Configuration;
|
||||
use std::io;
|
||||
|
||||
pub struct NetworkConfigurator {
|
||||
connection: Option<Connection>,
|
||||
recovery_key: String,
|
||||
}
|
||||
struct Connection {
|
||||
dns: dns::Installed,
|
||||
network: ip_helper::Installed,
|
||||
}
|
||||
impl NetworkConfigurator {
|
||||
/// The owner supplies an HKLM key under its administrator-controlled namespace.
|
||||
pub fn new(recovery_key: &str) -> io::Result<Self> {
|
||||
recovery::Journal::begin(recovery_key)?;
|
||||
Ok(Self {
|
||||
connection: None,
|
||||
recovery_key: recovery_key.into(),
|
||||
})
|
||||
}
|
||||
pub fn configure(&mut self, reason: &str, environment: &[(String, Option<String>)]) -> io::Result<()> {
|
||||
match reason {
|
||||
"pre-init" | "attempt-reconnect" => Ok(()),
|
||||
"connect" | "reconnect" => {
|
||||
let configuration = Configuration::parse(environment)?;
|
||||
self.disconnect()?;
|
||||
let network = ip_helper::Installed::apply(&configuration, &self.recovery_key)?;
|
||||
let dns = dns::Installed::apply(&configuration)?;
|
||||
self.connection = Some(Connection { dns, network });
|
||||
Ok(())
|
||||
}
|
||||
"disconnect" => self.disconnect(),
|
||||
_ => Err(io::Error::new(
|
||||
io::ErrorKind::InvalidInput,
|
||||
format!("Unknown VPN configuration reason: {reason}"),
|
||||
)),
|
||||
}
|
||||
}
|
||||
fn disconnect(&mut self) -> io::Result<()> {
|
||||
if let Some(mut connection) = self.connection.take() {
|
||||
let dns = connection.dns.restore();
|
||||
let network = connection.network.restore();
|
||||
dns.and(network)
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Restore process-owned physical routes and DNS policy before service admission.
|
||||
pub fn recover(recovery_key: &str) -> io::Result<()> {
|
||||
if let Some(journal) = recovery::Journal::open(recovery_key)? {
|
||||
for (name, route) in journal.routes()? {
|
||||
ip_helper::recover_route(&route)?;
|
||||
journal.forget(&name)?;
|
||||
}
|
||||
}
|
||||
dns::clear_stale_policies()
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
//! Ownership records for physical routes, retained across process termination.
|
||||
use ipnet::IpNet;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{io, net::IpAddr};
|
||||
use winreg::{RegKey, enums::*};
|
||||
|
||||
const PREFIX: &str = "Route-";
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub(super) struct Route {
|
||||
pub prefix: IpNet,
|
||||
pub next_hop: IpAddr,
|
||||
pub interface_luid: u64,
|
||||
pub metric: u32,
|
||||
pub prefix_scope: u32,
|
||||
pub next_hop_scope: u32,
|
||||
}
|
||||
pub(super) struct Journal(RegKey);
|
||||
impl Journal {
|
||||
pub fn begin(path: &str) -> io::Result<Self> {
|
||||
let (parent, name) = path
|
||||
.rsplit_once('\\')
|
||||
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Recovery key must have a registry parent"))?;
|
||||
let (parent, _) = RegKey::predef(HKEY_LOCAL_MACHINE).create_subkey(parent)?;
|
||||
// ActiveStore routes and this volatile key share the kernel's lifetime.
|
||||
// HKLM parent permissions restrict writes to SYSTEM and administrators.
|
||||
let (key, _) = parent.create_subkey_with_options_flags(name, REG_OPTION_VOLATILE, KEY_READ | KEY_WRITE)?;
|
||||
let journal = Self(key);
|
||||
if !journal.routes()?.is_empty() {
|
||||
return Err(io::Error::other(
|
||||
"Recover the previous Windows network state before connecting",
|
||||
));
|
||||
}
|
||||
Ok(journal)
|
||||
}
|
||||
pub fn open(path: &str) -> io::Result<Option<Self>> {
|
||||
match RegKey::predef(HKEY_LOCAL_MACHINE).open_subkey_with_flags(path, KEY_READ | KEY_WRITE) {
|
||||
Ok(key) => Ok(Some(Self(key))),
|
||||
Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(None),
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
}
|
||||
pub fn routes(&self) -> io::Result<Vec<(String, Route)>> {
|
||||
self
|
||||
.0
|
||||
.enum_values()
|
||||
.filter_map(|value| match value {
|
||||
Ok((name, _)) if name.starts_with(PREFIX) => Some((|| {
|
||||
let text: String = self.0.get_value(&name)?;
|
||||
let route = serde_json::from_str(&text).map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
|
||||
Ok((name, route))
|
||||
})()),
|
||||
Ok(_) => None,
|
||||
Err(error) => Some(Err(error)),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
pub fn record(&self, route: &Route) -> io::Result<String> {
|
||||
let name = format!("{PREFIX}{}", uuid::Uuid::new_v4());
|
||||
self
|
||||
.0
|
||||
.set_value(&name, &serde_json::to_string(route).map_err(io::Error::other)?)?;
|
||||
Ok(name)
|
||||
}
|
||||
pub fn forget(&self, name: &str) -> io::Result<()> {
|
||||
match self.0.delete_value(name) {
|
||||
Err(error) if error.kind() == io::ErrorKind::NotFound => Ok(()),
|
||||
result => result,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,454 @@
|
||||
#![cfg(windows)]
|
||||
//! Run as administrator with GP_TEST_WINTUN_DLL pointing to the signed Wintun DLL.
|
||||
use std::{ffi::c_void, io, net::IpAddr, os::windows::ffi::OsStrExt, path::PathBuf, ptr};
|
||||
use windows_sys::{
|
||||
Win32::{
|
||||
Foundation::{FreeLibrary, HMODULE},
|
||||
NetworkManagement::Ndis::NET_LUID_LH,
|
||||
System::LibraryLoader::*,
|
||||
},
|
||||
core::GUID,
|
||||
};
|
||||
type CloseAdapter = unsafe extern "system" fn(*mut c_void);
|
||||
type EndSession = unsafe extern "system" fn(*mut c_void);
|
||||
struct Library(HMODULE);
|
||||
impl Drop for Library {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
FreeLibrary(self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
struct Adapter {
|
||||
handle: *mut c_void,
|
||||
session: *mut c_void,
|
||||
close: CloseAdapter,
|
||||
end: EndSession,
|
||||
index: u32,
|
||||
_library: Library,
|
||||
}
|
||||
impl Adapter {
|
||||
fn create() -> Result<Self, Box<dyn std::error::Error>> {
|
||||
let path =
|
||||
PathBuf::from(std::env::var_os("GP_TEST_WINTUN_DLL").ok_or("GP_TEST_WINTUN_DLL is required")?).canonicalize()?;
|
||||
let path: Vec<u16> = path.as_os_str().encode_wide().chain(Some(0)).collect();
|
||||
let module = unsafe {
|
||||
LoadLibraryExW(
|
||||
path.as_ptr(),
|
||||
ptr::null_mut(),
|
||||
LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32,
|
||||
)
|
||||
};
|
||||
if module.is_null() {
|
||||
return Err(io::Error::last_os_error().into());
|
||||
}
|
||||
let library = Library(module);
|
||||
// Wintun's public C ABI uses WINAPI and pointer-sized opaque handles.
|
||||
let create: unsafe extern "system" fn(*const u16, *const u16, *const GUID) -> *mut c_void = unsafe {
|
||||
std::mem::transmute(
|
||||
GetProcAddress(module, c"WintunCreateAdapter".as_ptr().cast()).ok_or("Missing WintunCreateAdapter")?,
|
||||
)
|
||||
};
|
||||
let close: CloseAdapter = unsafe {
|
||||
std::mem::transmute(
|
||||
GetProcAddress(module, c"WintunCloseAdapter".as_ptr().cast()).ok_or("Missing WintunCloseAdapter")?,
|
||||
)
|
||||
};
|
||||
let luid: unsafe extern "system" fn(*mut c_void, *mut NET_LUID_LH) = unsafe {
|
||||
std::mem::transmute(
|
||||
GetProcAddress(module, c"WintunGetAdapterLUID".as_ptr().cast()).ok_or("Missing WintunGetAdapterLUID")?,
|
||||
)
|
||||
};
|
||||
let start: unsafe extern "system" fn(*mut c_void, u32) -> *mut c_void = unsafe {
|
||||
std::mem::transmute(
|
||||
GetProcAddress(module, c"WintunStartSession".as_ptr().cast()).ok_or("Missing WintunStartSession")?,
|
||||
)
|
||||
};
|
||||
let end: EndSession = unsafe {
|
||||
std::mem::transmute(
|
||||
GetProcAddress(module, c"WintunEndSession".as_ptr().cast()).ok_or("Missing WintunEndSession")?,
|
||||
)
|
||||
};
|
||||
let name: Vec<u16> = format!("GP Connect Test {}", uuid::Uuid::new_v4().simple())
|
||||
.encode_utf16()
|
||||
.chain(Some(0))
|
||||
.collect();
|
||||
let kind: Vec<u16> = "GP Connect".encode_utf16().chain(Some(0)).collect();
|
||||
let handle = unsafe { create(name.as_ptr(), kind.as_ptr(), ptr::null()) };
|
||||
if handle.is_null() {
|
||||
return Err(io::Error::last_os_error().into());
|
||||
}
|
||||
let mut adapter = Self {
|
||||
handle,
|
||||
session: ptr::null_mut(),
|
||||
close,
|
||||
end,
|
||||
index: 0,
|
||||
_library: library,
|
||||
};
|
||||
let mut id = NET_LUID_LH::default();
|
||||
unsafe {
|
||||
luid(handle, &mut id);
|
||||
}
|
||||
check(unsafe { ConvertInterfaceLuidToIndex(&id, &mut adapter.index) });
|
||||
adapter.session = unsafe { start(handle, 0x400000) };
|
||||
if adapter.session.is_null() {
|
||||
return Err(io::Error::last_os_error().into());
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_secs(1));
|
||||
Ok(adapter)
|
||||
}
|
||||
}
|
||||
impl Drop for Adapter {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
if !self.session.is_null() {
|
||||
(self.end)(self.session);
|
||||
}
|
||||
(self.close)(self.handle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
use gpvpnc::windows::NetworkConfigurator;
|
||||
use windows_sys::Win32::{NetworkManagement::IpHelper::*, Networking::WinSock::*};
|
||||
fn check(status: u32) {
|
||||
assert_eq!(
|
||||
status,
|
||||
0,
|
||||
"Native IP Helper failed: {}",
|
||||
io::Error::from_raw_os_error(status as i32)
|
||||
);
|
||||
}
|
||||
fn address(value: &SOCKADDR_INET) -> IpAddr {
|
||||
unsafe {
|
||||
match value.si_family {
|
||||
AF_INET => std::net::Ipv4Addr::from(value.Ipv4.sin_addr.S_un.S_addr.to_ne_bytes()).into(),
|
||||
AF_INET6 => std::net::Ipv6Addr::from(value.Ipv6.sin6_addr.u.Byte).into(),
|
||||
_ => panic!("unexpected family"),
|
||||
}
|
||||
}
|
||||
}
|
||||
fn routes(index: Option<u32>) -> Vec<String> {
|
||||
let mut result = Vec::new();
|
||||
unsafe {
|
||||
let mut table = std::ptr::null_mut();
|
||||
check(GetIpForwardTable2(AF_UNSPEC, &mut table));
|
||||
for row in std::slice::from_raw_parts((*table).Table.as_ptr(), (*table).NumEntries as usize) {
|
||||
if Some(row.InterfaceIndex) != index
|
||||
&& !["198.51.100.1", "203.0.113.128"].contains(&address(&row.DestinationPrefix.Prefix).to_string().as_str())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
result.push(format!(
|
||||
"route {} {}/{} {} {}",
|
||||
row.InterfaceIndex,
|
||||
address(&row.DestinationPrefix.Prefix),
|
||||
row.DestinationPrefix.PrefixLength,
|
||||
address(&row.NextHop),
|
||||
row.Metric
|
||||
));
|
||||
}
|
||||
FreeMibTable(table.cast());
|
||||
}
|
||||
result.sort();
|
||||
result
|
||||
}
|
||||
fn state(index: u32) -> Vec<String> {
|
||||
let mut result = routes(Some(index));
|
||||
unsafe {
|
||||
let mut table = std::ptr::null_mut();
|
||||
check(GetUnicastIpAddressTable(AF_UNSPEC, &mut table));
|
||||
for row in std::slice::from_raw_parts((*table).Table.as_ptr(), (*table).NumEntries as usize) {
|
||||
if row.InterfaceIndex == index {
|
||||
result.push(format!("address {}/{}", address(&row.Address), row.OnLinkPrefixLength));
|
||||
}
|
||||
}
|
||||
FreeMibTable(table.cast());
|
||||
for family in [AF_INET, AF_INET6] {
|
||||
let mut row = MIB_IPINTERFACE_ROW {
|
||||
Family: family,
|
||||
InterfaceIndex: index,
|
||||
..Default::default()
|
||||
};
|
||||
check(GetIpInterfaceEntry(&mut row));
|
||||
result.push(format!(
|
||||
"interface {} {} {} {} {}",
|
||||
family, row.Metric, row.UseAutomaticMetric, row.NlMtu, row.DadTransmits
|
||||
));
|
||||
}
|
||||
}
|
||||
unsafe {
|
||||
let mut luid = NET_LUID_LH::default();
|
||||
let mut guid = GUID::default();
|
||||
check(ConvertInterfaceIndexToLuid(index, &mut luid));
|
||||
check(ConvertInterfaceLuidToGuid(&luid, &mut guid));
|
||||
let mut dns = DNS_INTERFACE_SETTINGS {
|
||||
Version: DNS_INTERFACE_SETTINGS_VERSION1,
|
||||
..Default::default()
|
||||
};
|
||||
check(GetInterfaceDnsSettings(guid, &mut dns));
|
||||
for (name, pointer) in [
|
||||
("dns-domain", dns.Domain),
|
||||
("dns-search", dns.SearchList),
|
||||
("dns-servers", dns.NameServer),
|
||||
] {
|
||||
let mut length = 0;
|
||||
if !pointer.is_null() {
|
||||
while *pointer.add(length) != 0 {
|
||||
length += 1;
|
||||
}
|
||||
}
|
||||
let text = if pointer.is_null() {
|
||||
String::new()
|
||||
} else {
|
||||
String::from_utf16_lossy(std::slice::from_raw_parts(pointer, length))
|
||||
};
|
||||
result.push(format!("{name} {text}"));
|
||||
}
|
||||
FreeInterfaceDnsSettings(&mut dns);
|
||||
}
|
||||
result.sort();
|
||||
result
|
||||
}
|
||||
fn best_route(destination: &str) -> MIB_IPFORWARD_ROW2 {
|
||||
let ip: IpAddr = destination.parse().unwrap();
|
||||
let mut destination = SOCKADDR_INET::default();
|
||||
match ip {
|
||||
IpAddr::V4(ip) => {
|
||||
destination.Ipv4.sin_family = AF_INET;
|
||||
destination.Ipv4.sin_addr.S_un.S_addr = u32::from_ne_bytes(ip.octets());
|
||||
}
|
||||
IpAddr::V6(ip) => {
|
||||
destination.Ipv6.sin6_family = AF_INET6;
|
||||
destination.Ipv6.sin6_addr.u.Byte = ip.octets();
|
||||
}
|
||||
}
|
||||
let mut route = MIB_IPFORWARD_ROW2::default();
|
||||
let mut source = SOCKADDR_INET::default();
|
||||
check(unsafe { GetBestRoute2(ptr::null(), 0, ptr::null(), &destination, 0, &mut route, &mut source) });
|
||||
route
|
||||
}
|
||||
|
||||
fn assert_dns_policy(active: bool) {
|
||||
const CHECK: &str = r#"
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$ProgressPreference = 'SilentlyContinue'
|
||||
$expected = [int]$env:GP_TEST_EXPECTED_DNS_POLICIES
|
||||
$configured = @(Get-DnsClientNrptRule | Where-Object { $_.Namespace -contains '.gp-connect-test.invalid' })
|
||||
$effective = @(Get-DnsClientNrptPolicy | Where-Object { $_.Namespace -contains '.gp-connect-test.invalid' })
|
||||
if ($configured.Count -ne $expected -or $effective.Count -ne $expected) { throw 'Unexpected configured or effective VPN DNS policy' }
|
||||
if ($expected) {
|
||||
$servers = @($configured[0].NameServers)
|
||||
if ($servers -notcontains '198.18.0.53' -or $servers -notcontains 'fd42:1235::53') { throw 'VPN DNS server families are missing' }
|
||||
}
|
||||
"#;
|
||||
let powershell =
|
||||
PathBuf::from(std::env::var_os("SystemRoot").unwrap()).join("System32/WindowsPowerShell/v1.0/powershell.exe");
|
||||
let output = std::process::Command::new(powershell)
|
||||
.args(["-NoProfile", "-NonInteractive", "-Command", CHECK])
|
||||
.env("GP_TEST_EXPECTED_DNS_POLICIES", if active { "1" } else { "0" })
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "requires administrator privileges and GP_TEST_WINTUN_DLL"]
|
||||
fn installs_and_restores_native_network_configuration() -> Result<(), Box<dyn std::error::Error>> {
|
||||
let adapter = Adapter::create()?;
|
||||
let index = adapter.index;
|
||||
if let Some(recovery_key) = std::env::var_os("GP_TEST_CRASH_KEY") {
|
||||
let recovery_key = recovery_key.to_str().ok_or("Invalid registry key")?;
|
||||
let mut network = NetworkConfigurator::new(recovery_key)?;
|
||||
network.configure("connect", &environment(index))?;
|
||||
std::fs::write(
|
||||
std::env::var_os("GP_TEST_CRASH_READY").ok_or("Missing readiness path")?,
|
||||
index.to_string(),
|
||||
)?;
|
||||
loop {
|
||||
std::thread::park();
|
||||
}
|
||||
}
|
||||
let environment = environment(index);
|
||||
let recovery_key = format!(r"SOFTWARE\GP Connect\Tests\Network{}", uuid::Uuid::new_v4().simple());
|
||||
assert_dns_policy(false);
|
||||
let before = state(index);
|
||||
{
|
||||
let mut network = NetworkConfigurator::new(&recovery_key)?;
|
||||
network.configure("connect", &environment)?;
|
||||
let during = state(index);
|
||||
assert!(during.iter().any(|row| row == "address 192.0.2.2/24"));
|
||||
assert!(during.iter().any(|row| row == "address fd42:1234::2/64"));
|
||||
assert!(
|
||||
during
|
||||
.iter()
|
||||
.any(|row| row.starts_with(&format!("route {index} 203.0.113.0/24 ")))
|
||||
);
|
||||
assert!(
|
||||
during
|
||||
.iter()
|
||||
.any(|row| row.starts_with(&format!("route {index} 2001:db8:1234::/64 ")))
|
||||
);
|
||||
assert_eq!(best_route("203.0.113.1").InterfaceIndex, index);
|
||||
assert_eq!(best_route("2001:db8:1234::1").InterfaceIndex, index);
|
||||
assert_eq!(best_route("198.18.0.53").InterfaceIndex, index);
|
||||
assert_eq!(best_route("fd42:1235::53").InterfaceIndex, index);
|
||||
assert_ne!(best_route("203.0.113.200").InterfaceIndex, index);
|
||||
assert_ne!(best_route("198.51.100.1").InterfaceIndex, index);
|
||||
println!("PASS: IPv4/IPv6 addresses, split routes, resolver routes and MTU installed");
|
||||
assert_dns_policy(true);
|
||||
network.configure("disconnect", &[])?;
|
||||
}
|
||||
assert_eq!(before, state(index), "Network state was not restored");
|
||||
assert_dns_policy(false);
|
||||
println!("PASS: disconnect restored addresses, routes and interface settings");
|
||||
{
|
||||
let mut network = NetworkConfigurator::new(&recovery_key)?;
|
||||
network.configure("connect", &environment)?;
|
||||
}
|
||||
assert_eq!(
|
||||
before,
|
||||
state(index),
|
||||
"Dropping the connection did not restore network state"
|
||||
);
|
||||
assert_dns_policy(false);
|
||||
let mut invalid = environment.clone();
|
||||
invalid[0].1 = Some(u32::MAX.to_string());
|
||||
assert!(
|
||||
NetworkConfigurator::new(&recovery_key)?
|
||||
.configure("connect", &invalid)
|
||||
.is_err()
|
||||
);
|
||||
assert_eq!(before, state(index), "Failed connection left a physical gateway route");
|
||||
println!("PASS: partial setup failure rolled back its physical gateway route");
|
||||
drop(adapter);
|
||||
assert_crash_recovery(&recovery_key)?;
|
||||
winreg::RegKey::predef(winreg::enums::HKEY_LOCAL_MACHINE).delete_subkey(&recovery_key)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn environment(index: u32) -> Vec<(String, Option<String>)> {
|
||||
let pairs = [
|
||||
("TUNIDX", index.to_string()),
|
||||
("VPNGATEWAY", "198.51.100.1".into()),
|
||||
("INTERNAL_IP4_ADDRESS", "192.0.2.2".into()),
|
||||
("INTERNAL_IP4_NETMASKLEN", "24".into()),
|
||||
("INTERNAL_IP6_ADDRESS", "fd42:1234::2".into()),
|
||||
("INTERNAL_IP6_NETMASK", "fd42:1234::2/64".into()),
|
||||
("INTERNAL_IP4_MTU", "1406".into()),
|
||||
("CISCO_SPLIT_INC", "1".into()),
|
||||
("CISCO_SPLIT_INC_0_ADDR", "203.0.113.0".into()),
|
||||
("CISCO_SPLIT_INC_0_MASKLEN", "24".into()),
|
||||
("CISCO_SPLIT_EXC", "1".into()),
|
||||
("CISCO_SPLIT_EXC_0_ADDR", "203.0.113.128".into()),
|
||||
("CISCO_SPLIT_EXC_0_MASKLEN", "25".into()),
|
||||
("CISCO_IPV6_SPLIT_INC", "1".into()),
|
||||
("CISCO_IPV6_SPLIT_INC_0_ADDR", "2001:db8:1234::".into()),
|
||||
("CISCO_IPV6_SPLIT_INC_0_MASKLEN", "64".into()),
|
||||
("INTERNAL_IP4_DNS", "198.18.0.53 fd42:1235::53".into()),
|
||||
("CISCO_DEF_DOMAIN", "gp-connect-test.invalid".into()),
|
||||
("CISCO_SPLIT_DNS", "gp-connect-test.invalid".into()),
|
||||
];
|
||||
pairs
|
||||
.into_iter()
|
||||
.map(|(key, value)| (key.to_string(), Some(value)))
|
||||
.collect()
|
||||
}
|
||||
|
||||
struct CrashChild {
|
||||
child: std::process::Child,
|
||||
key: String,
|
||||
modified_route: Option<MIB_IPFORWARD_ROW2>,
|
||||
}
|
||||
impl Drop for CrashChild {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.child.kill();
|
||||
let _ = self.child.wait();
|
||||
if let Some(route) = self.modified_route.take() {
|
||||
unsafe {
|
||||
DeleteIpForwardEntry2(&route);
|
||||
}
|
||||
}
|
||||
let _ = gpvpnc::windows::recover(&self.key);
|
||||
}
|
||||
}
|
||||
fn assert_crash_recovery(key: &str) -> Result<(), Box<dyn std::error::Error>> {
|
||||
let before = routes(None);
|
||||
let directory = tempfile::tempdir()?;
|
||||
let ready = directory.path().join("ready");
|
||||
let child = std::process::Command::new(std::env::current_exe()?)
|
||||
.args([
|
||||
"--ignored",
|
||||
"--exact",
|
||||
"installs_and_restores_native_network_configuration",
|
||||
])
|
||||
.env("GP_TEST_CRASH_KEY", key)
|
||||
.env("GP_TEST_CRASH_READY", &ready)
|
||||
.stdout(std::process::Stdio::null())
|
||||
.spawn()?;
|
||||
let mut child = CrashChild {
|
||||
child,
|
||||
key: key.into(),
|
||||
modified_route: None,
|
||||
};
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
|
||||
while !ready.exists() {
|
||||
if child.child.try_wait()?.is_some() || std::time::Instant::now() > deadline {
|
||||
return Err("Crash child did not install its network state".into());
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
}
|
||||
let child_index: u32 = std::fs::read_to_string(&ready)?.parse()?;
|
||||
assert_dns_policy(true);
|
||||
let dirty = routes(None);
|
||||
assert_ne!(before, dirty, "Child did not create physical routes");
|
||||
child.child.kill()?;
|
||||
child.child.wait()?;
|
||||
assert_dns_policy(true);
|
||||
let mut addresses = ptr::null_mut();
|
||||
check(unsafe { GetUnicastIpAddressTable(AF_UNSPEC, &mut addresses) });
|
||||
let child_addresses = unsafe {
|
||||
std::slice::from_raw_parts((*addresses).Table.as_ptr(), (*addresses).NumEntries as usize)
|
||||
.iter()
|
||||
.any(|row| row.InterfaceIndex == child_index)
|
||||
};
|
||||
unsafe {
|
||||
FreeMibTable(addresses.cast());
|
||||
}
|
||||
assert!(!child_addresses, "Terminated process left its Wintun addresses");
|
||||
assert_ne!(
|
||||
before,
|
||||
routes(None),
|
||||
"Physical routes unexpectedly disappeared with the process"
|
||||
);
|
||||
// Model an administrator taking ownership of an exclusion after the crash.
|
||||
let mut modified = best_route("203.0.113.200");
|
||||
assert_eq!(address(&modified.DestinationPrefix.Prefix).to_string(), "203.0.113.128");
|
||||
modified.Metric += 1;
|
||||
check(unsafe { SetIpForwardEntry2(&modified) });
|
||||
child.modified_route = Some(modified);
|
||||
let mut expected = before.clone();
|
||||
expected.push(format!(
|
||||
"route {} {}/{} {} {}",
|
||||
modified.InterfaceIndex,
|
||||
address(&modified.DestinationPrefix.Prefix),
|
||||
modified.DestinationPrefix.PrefixLength,
|
||||
address(&modified.NextHop),
|
||||
modified.Metric
|
||||
));
|
||||
expected.sort();
|
||||
gpvpnc::windows::recover(key)?;
|
||||
assert_eq!(
|
||||
expected,
|
||||
routes(None),
|
||||
"Recovery must remove owned routes and preserve the changed route"
|
||||
);
|
||||
assert_dns_policy(false);
|
||||
drop(NetworkConfigurator::new(key)?);
|
||||
check(unsafe { DeleteIpForwardEntry2(&modified) });
|
||||
child.modified_route = None;
|
||||
assert_eq!(before, routes(None), "Crash recovery did not restore the baseline");
|
||||
println!("PASS: crash recovery removed owned physical routes and DNS policy and preserved an administrator's change");
|
||||
Ok(())
|
||||
}
|
||||
@@ -19,3 +19,6 @@ fs_extra = "1"
|
||||
|
||||
[dev-dependencies]
|
||||
tempfile = "3"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
windows-sys = { version = "0.61", features = ["Win32_Networking_WinSock"] }
|
||||
@@ -1,3 +1,6 @@
|
||||
#[path = "build/windows.rs"]
|
||||
mod windows;
|
||||
|
||||
use std::{env, path::PathBuf};
|
||||
|
||||
fn build_libxml2(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
|
||||
@@ -188,6 +191,10 @@ fn build_openconnect(deps_dir: &PathBuf, out_dir: &PathBuf) -> PathBuf {
|
||||
|
||||
fn main() {
|
||||
let target = target_os();
|
||||
if target == "windows" {
|
||||
windows::build();
|
||||
return;
|
||||
}
|
||||
assert!(
|
||||
matches!(target.as_str(), "macos" | "linux" | "freebsd" | "openbsd"),
|
||||
"Unsupported OpenConnect target: {target}"
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
//! Link the MinGW-built OpenConnect DLL into the native MSVC Rust service.
|
||||
use std::{env, path::PathBuf};
|
||||
|
||||
pub fn build() {
|
||||
println!("cargo:rerun-if-env-changed=OPENCONNECT_WINDOWS_PREFIX");
|
||||
let prefix = PathBuf::from(
|
||||
env::var_os("OPENCONNECT_WINDOWS_PREFIX")
|
||||
.expect("Build native OpenConnect and set OPENCONNECT_WINDOWS_PREFIX to its install directory"),
|
||||
);
|
||||
let include = prefix.join("include");
|
||||
let library = prefix.join("lib");
|
||||
assert!(
|
||||
library.join("openconnect.lib").is_file(),
|
||||
"The native OpenConnect MSVC import library is missing"
|
||||
);
|
||||
println!("cargo:rerun-if-changed={}", library.join("openconnect.lib").display());
|
||||
println!("cargo:rerun-if-changed={}", include.join("openconnect.h").display());
|
||||
println!("cargo:rustc-link-search=native={}", library.display());
|
||||
println!("cargo:rustc-link-lib=dylib=openconnect");
|
||||
println!("cargo:rustc-link-lib=ws2_32");
|
||||
println!("cargo:include={}", include.display());
|
||||
println!("cargo:lib_dir={}", prefix.join("bin").display());
|
||||
println!("cargo:rerun-if-changed=src/ffi/vpn.c");
|
||||
println!("cargo:rerun-if-changed=src/ffi/vpn.h");
|
||||
cc::Build::new()
|
||||
.file("src/ffi/vpn.c")
|
||||
.include("src/ffi")
|
||||
.include(include)
|
||||
.std("c11")
|
||||
.compile("vpn");
|
||||
}
|
||||
Submodule crates/openconnect/deps/openconnect updated: 43b36d7293...c312e48d4f.
@@ -1,7 +1,11 @@
|
||||
#[cfg(unix)]
|
||||
use libc::{AF_INET, AF_INET6, addrinfo, getaddrinfo};
|
||||
use std::{
|
||||
ffi::{c_char, c_int},
|
||||
ptr,
|
||||
};
|
||||
#[cfg(windows)]
|
||||
use windows_sys::Win32::Networking::WinSock::{ADDRINFOA as addrinfo, AF_INET, AF_INET6, getaddrinfo};
|
||||
|
||||
/// Resolve with the system's normal policy, then prefer one family without
|
||||
/// discarding alternatives. The returned list remains owned by libc and is
|
||||
@@ -13,18 +17,18 @@ use std::{
|
||||
pub unsafe extern "C" fn vpn_resolve_gateway(
|
||||
node: *const c_char,
|
||||
service: *const c_char,
|
||||
hints: *const libc::addrinfo,
|
||||
result: *mut *mut libc::addrinfo,
|
||||
hints: *const addrinfo,
|
||||
result: *mut *mut addrinfo,
|
||||
preference: u32,
|
||||
) -> c_int {
|
||||
// SAFETY: The OpenConnect callback forwards valid getaddrinfo arguments.
|
||||
let status = unsafe { libc::getaddrinfo(node, service, hints, result) };
|
||||
let status = unsafe { getaddrinfo(node.cast(), service.cast(), hints, result) };
|
||||
if status != 0 {
|
||||
return status;
|
||||
}
|
||||
let family = match preference {
|
||||
4 => libc::AF_INET,
|
||||
6 => libc::AF_INET6,
|
||||
4 => AF_INET as c_int,
|
||||
6 => AF_INET6 as c_int,
|
||||
_ => return 0,
|
||||
};
|
||||
// SAFETY: A successful getaddrinfo call returns an owned, writable list.
|
||||
@@ -34,7 +38,7 @@ pub unsafe extern "C" fn vpn_resolve_gateway(
|
||||
|
||||
/// # Safety
|
||||
/// `head` must be an exclusively owned, writable addrinfo list with no cycles.
|
||||
unsafe fn prefer_family(head: *mut libc::addrinfo, family: c_int) -> *mut libc::addrinfo {
|
||||
unsafe fn prefer_family(head: *mut addrinfo, family: c_int) -> *mut addrinfo {
|
||||
let mut addresses = Vec::new();
|
||||
let mut current = head;
|
||||
// SAFETY: The caller owns every node; sorting only changes the list links.
|
||||
|
||||
@@ -1,3 +1,8 @@
|
||||
#[cfg(unix)]
|
||||
pub(crate) type CommandHandle = i32;
|
||||
#[cfg(windows)]
|
||||
pub(crate) type CommandHandle = usize;
|
||||
|
||||
mod gateway;
|
||||
mod hip;
|
||||
mod network_configuration;
|
||||
@@ -41,9 +46,11 @@ pub(crate) struct ConnectOptions {
|
||||
|
||||
pub script: *const c_char,
|
||||
pub configure_network: Option<unsafe extern "C" fn(*mut c_void, *const c_char, *const VpnOptionRaw) -> c_int>,
|
||||
pub interface: *const c_char,
|
||||
pub interface_name: *const c_char,
|
||||
pub script_tun: u32,
|
||||
pub script_tun_launch: *const ScriptTunLaunchRaw,
|
||||
#[cfg(windows)]
|
||||
pub script_tun_pipe: isize,
|
||||
|
||||
pub certificate: *const c_char,
|
||||
pub sslkey: *const c_char,
|
||||
@@ -77,17 +84,17 @@ pub(crate) struct VpnSessionInfoRaw {
|
||||
|
||||
#[link(name = "vpn")]
|
||||
unsafe extern "C" {
|
||||
fn vpn_write_cancel(fd: c_int) -> c_int;
|
||||
fn vpn_write_statistics(fd: c_int) -> c_int;
|
||||
fn vpn_write_cancel(fd: CommandHandle) -> c_int;
|
||||
fn vpn_write_statistics(fd: CommandHandle) -> c_int;
|
||||
#[link_name = "vpn_connect"]
|
||||
fn vpn_connect(
|
||||
options: *const ConnectOptions,
|
||||
callback: extern "C" fn(i32, *const VpnSessionInfoRaw, *mut c_void),
|
||||
callback: extern "C" fn(CommandHandle, *const VpnSessionInfoRaw, *mut c_void),
|
||||
) -> c_int;
|
||||
|
||||
}
|
||||
|
||||
pub(crate) fn write_cancel(fd: i32) -> std::io::Result<()> {
|
||||
pub(crate) fn write_cancel(fd: CommandHandle) -> std::io::Result<()> {
|
||||
let error = unsafe { vpn_write_cancel(fd) };
|
||||
if error == 0 {
|
||||
Ok(())
|
||||
@@ -96,7 +103,7 @@ pub(crate) fn write_cancel(fd: i32) -> std::io::Result<()> {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn write_statistics(fd: i32) -> std::io::Result<()> {
|
||||
pub(crate) fn write_statistics(fd: CommandHandle) -> std::io::Result<()> {
|
||||
let error = unsafe { vpn_write_statistics(fd) };
|
||||
if error == 0 {
|
||||
Ok(())
|
||||
@@ -106,7 +113,7 @@ pub(crate) fn write_statistics(fd: i32) -> std::io::Result<()> {
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn vpn_attach_command_pipe(vpn: *mut c_void, fd: c_int) -> c_int {
|
||||
extern "C" fn vpn_attach_command_pipe(vpn: *mut c_void, fd: CommandHandle) -> c_int {
|
||||
unsafe { &*(vpn as *const Vpn) }.attach_command_pipe(fd).into()
|
||||
}
|
||||
|
||||
@@ -134,7 +141,7 @@ pub(crate) extern "C" fn on_hip_report_submitted(vpn: *mut c_void, report: *cons
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn on_vpn_connected(pipe_fd: i32, session_info: *const VpnSessionInfoRaw, vpn: *mut c_void) {
|
||||
extern "C" fn on_vpn_connected(pipe_fd: CommandHandle, session_info: *const VpnSessionInfoRaw, vpn: *mut c_void) {
|
||||
let vpn = unsafe { &*(vpn as *const Vpn) };
|
||||
vpn.on_connected(pipe_fd, crate::vpn::session_info_from_raw(session_info));
|
||||
}
|
||||
|
||||
@@ -1,16 +1,15 @@
|
||||
#include <openconnect.h>
|
||||
#include "vpn.h"
|
||||
#include <errno.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/utsname.h>
|
||||
#ifndef _WIN32
|
||||
#include <unistd.h>
|
||||
|
||||
#include "vpn.h"
|
||||
#endif
|
||||
|
||||
struct vpn_context {
|
||||
struct openconnect_info *vpninfo;
|
||||
int command_fd;
|
||||
vpn_command_handle command_fd;
|
||||
const vpn_options *options;
|
||||
vpn_connected_callback on_connected;
|
||||
};
|
||||
@@ -59,21 +58,22 @@ static int validate_peer_cert(void *private_data,
|
||||
if (context->options->servercert)
|
||||
return openconnect_check_peer_cert_hash(context->vpninfo,
|
||||
context->options->servercert);
|
||||
INFO("Accepting the server certificate though %s", reason);
|
||||
VPN_INFO("Accepting the server certificate though %s", reason);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Print progress messages */
|
||||
static void print_progress(__attribute__((unused)) void *_vpninfo, int level,
|
||||
static void print_progress(void *_vpninfo, int level,
|
||||
const char *format, ...)
|
||||
{
|
||||
(void)_vpninfo;
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
char *message = format_message(format, args);
|
||||
va_end(args);
|
||||
|
||||
if (message == NULL) {
|
||||
ERROR("Failed to format log message");
|
||||
VPN_ERROR("Failed to format log message");
|
||||
} else {
|
||||
vpn_log(level, message);
|
||||
free(message);
|
||||
@@ -88,15 +88,24 @@ static void setup_tun_handler(void *private_data)
|
||||
int ret;
|
||||
if (options->script_tun) {
|
||||
const struct openconnect_script_tun_launch *launch = options->script_tun_launch;
|
||||
#ifdef _WIN32
|
||||
if (options->script_tun_pipe != -1) {
|
||||
ret = openconnect_setup_tun_pipe(_vpninfo, options->script_tun_pipe);
|
||||
} else
|
||||
#endif
|
||||
if (launch) {
|
||||
#ifndef _WIN32
|
||||
ret = openconnect_setup_tun_script_exec(_vpninfo, launch);
|
||||
vpn_script_started(options->user_data);
|
||||
#else
|
||||
ret = -EOPNOTSUPP;
|
||||
#endif
|
||||
} else {
|
||||
ret = openconnect_setup_tun_script(_vpninfo, options->script);
|
||||
}
|
||||
} else {
|
||||
ret = openconnect_setup_tun_device(_vpninfo, options->script,
|
||||
options->interface);
|
||||
options->interface_name);
|
||||
}
|
||||
|
||||
if (!ret) {
|
||||
@@ -122,39 +131,39 @@ static void setup_tun_handler(void *private_data)
|
||||
int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
|
||||
{
|
||||
struct openconnect_info *vpninfo;
|
||||
struct utsname utsbuf;
|
||||
char hostname[256];
|
||||
const char *effective_local_hostname = NULL;
|
||||
|
||||
struct vpn_context context = { .options = options, .on_connected = callback };
|
||||
int result = 1;
|
||||
|
||||
INFO("USER_AGENT: %s", options->user_agent);
|
||||
INFO("OS: %s", options->os);
|
||||
INFO("CLIENT_VERSION: %s", options->client_version);
|
||||
INFO("HOST_ID: %s", options->host_id ? options->host_id : "(not set)");
|
||||
VPN_INFO("USER_AGENT: %s", options->user_agent);
|
||||
VPN_INFO("OS: %s", options->os);
|
||||
VPN_INFO("CLIENT_VERSION: %s", options->client_version);
|
||||
VPN_INFO("HOST_ID: %s", options->host_id ? options->host_id : "(not set)");
|
||||
const char *configuration = options->script;
|
||||
if (options->configure_network)
|
||||
configuration = "callback";
|
||||
else if (options->script_tun_launch)
|
||||
configuration = options->script_tun_launch->program;
|
||||
INFO("Network configuration: %s", configuration);
|
||||
INFO("SCRIPT_TUN: %d", options->script_tun);
|
||||
INFO("CSD_USER: %d", options->hip_script.uid);
|
||||
INFO("CSD_WRAPPER: %s", options->hip_script.path);
|
||||
INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
|
||||
INFO("MTU: %d", options->mtu);
|
||||
INFO("DISABLE_IPV6: %d", options->disable_ipv6);
|
||||
INFO("GATEWAY_IP_PREFERENCE: %d", options->gateway_ip_preference);
|
||||
INFO("NO_DTLS: %d", options->no_dtls);
|
||||
INFO("DPD_INTERVAL: %d", options->dpd_interval);
|
||||
INFO("NO_XMLPOST: %d", options->no_xmlpost);
|
||||
VPN_INFO("Network configuration: %s", configuration);
|
||||
VPN_INFO("SCRIPT_TUN: %d", options->script_tun);
|
||||
VPN_INFO("CSD_USER: %d", options->hip_script.uid);
|
||||
VPN_INFO("CSD_WRAPPER: %s", options->hip_script.path);
|
||||
VPN_INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
|
||||
VPN_INFO("MTU: %d", options->mtu);
|
||||
VPN_INFO("DISABLE_IPV6: %d", options->disable_ipv6);
|
||||
VPN_INFO("GATEWAY_IP_PREFERENCE: %d", options->gateway_ip_preference);
|
||||
VPN_INFO("NO_DTLS: %d", options->no_dtls);
|
||||
VPN_INFO("DPD_INTERVAL: %d", options->dpd_interval);
|
||||
VPN_INFO("NO_XMLPOST: %d", options->no_xmlpost);
|
||||
|
||||
vpninfo =
|
||||
openconnect_vpninfo_new(options->user_agent, validate_peer_cert,
|
||||
NULL, NULL, print_progress, &context);
|
||||
|
||||
if (!vpninfo) {
|
||||
ERROR("openconnect_vpninfo_new failed");
|
||||
VPN_ERROR("openconnect_vpninfo_new failed");
|
||||
vpn_tunnel_event(options->user_data, VPN_TUNNEL_ENDED);
|
||||
return 1;
|
||||
}
|
||||
@@ -168,20 +177,21 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
|
||||
openconnect_set_stats_handler(vpninfo, observe_statistics);
|
||||
openconnect_set_gp_hip_report_callback(vpninfo, options->user_data,
|
||||
options->on_hip_report_submitted);
|
||||
/* Windows command pipes are Winsock sockets. Initialize before creating them. */
|
||||
openconnect_init_ssl();
|
||||
context.command_fd = openconnect_setup_cmd_pipe(vpninfo);
|
||||
if (context.command_fd < 0) {
|
||||
ERROR("openconnect_setup_cmd_pipe failed");
|
||||
if (context.command_fd == (vpn_command_handle)-1) {
|
||||
VPN_ERROR("openconnect_setup_cmd_pipe failed");
|
||||
goto cleanup;
|
||||
}
|
||||
/* An earlier disconnect remains latched on this attempt. */
|
||||
if (vpn_attach_command_pipe(options->user_data, context.command_fd)) {
|
||||
INFO("VPN attempt canceled before startup");
|
||||
VPN_INFO("VPN attempt canceled before startup");
|
||||
result = -EINTR;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
openconnect_set_loglevel(vpninfo, PRG_TRACE);
|
||||
openconnect_init_ssl();
|
||||
openconnect_set_protocol(vpninfo, "gp");
|
||||
openconnect_parse_url(vpninfo, options->server);
|
||||
if (options->gateway_ip_preference)
|
||||
@@ -207,18 +217,19 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
|
||||
}
|
||||
|
||||
effective_local_hostname = options->local_hostname;
|
||||
if (!effective_local_hostname && !uname(&utsbuf)) {
|
||||
effective_local_hostname = utsbuf.nodename;
|
||||
if (!effective_local_hostname && !gethostname(hostname, sizeof(hostname))) {
|
||||
hostname[sizeof(hostname) - 1] = 0;
|
||||
effective_local_hostname = hostname;
|
||||
}
|
||||
if (effective_local_hostname) {
|
||||
openconnect_set_localname(vpninfo, effective_local_hostname);
|
||||
}
|
||||
|
||||
INFO("LOCAL_HOSTNAME: %s",
|
||||
VPN_INFO("LOCAL_HOSTNAME: %s",
|
||||
effective_local_hostname ? effective_local_hostname : "(not set)");
|
||||
|
||||
if (options->certificate) {
|
||||
INFO("Setting client certificate: %s", options->certificate);
|
||||
VPN_INFO("Setting client certificate: %s", options->certificate);
|
||||
openconnect_set_client_cert(vpninfo, options->certificate,
|
||||
options->sslkey);
|
||||
}
|
||||
@@ -256,7 +267,7 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
|
||||
// Essential step
|
||||
vpn_tunnel_event(options->user_data, OC_TUNNEL_NEGOTIATING);
|
||||
if (openconnect_make_cstp_connection(vpninfo) != 0) {
|
||||
ERROR("openconnect_make_cstp_connection failed");
|
||||
VPN_ERROR("openconnect_make_cstp_connection failed");
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
@@ -273,12 +284,12 @@ int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
|
||||
options->reconnect_timeout, 10);
|
||||
|
||||
if (ret) {
|
||||
INFO("openconnect_mainloop returned %d, exiting", ret);
|
||||
VPN_INFO("openconnect_mainloop returned %d, exiting", ret);
|
||||
result = ret;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
INFO("openconnect_mainloop returned 0, reconnecting");
|
||||
VPN_INFO("openconnect_mainloop returned 0, reconnecting");
|
||||
}
|
||||
cleanup:
|
||||
vpn_detach_command_pipe(options->user_data);
|
||||
@@ -289,24 +300,28 @@ cleanup:
|
||||
}
|
||||
|
||||
/* Called with the attempt cancellation mutex held, never after detach/free. */
|
||||
int vpn_write_cancel(int fd)
|
||||
static int write_command(vpn_command_handle fd, char command)
|
||||
{
|
||||
char command = OC_CMD_CANCEL;
|
||||
#ifdef _WIN32
|
||||
int written = send(fd, &command, 1, 0);
|
||||
return written == 1 ? 0 : (written == SOCKET_ERROR ? WSAGetLastError() : EIO);
|
||||
#else
|
||||
ssize_t written;
|
||||
do {
|
||||
written = write(fd, &command, 1);
|
||||
} while (written < 0 && errno == EINTR);
|
||||
return written == 1 ? 0 : (written < 0 ? errno : EIO);
|
||||
#endif
|
||||
}
|
||||
|
||||
int vpn_write_statistics(int fd)
|
||||
int vpn_write_cancel(vpn_command_handle fd)
|
||||
{
|
||||
char command = OC_CMD_STATS;
|
||||
ssize_t written;
|
||||
do {
|
||||
written = write(fd, &command, 1);
|
||||
} while (written < 0 && errno == EINTR);
|
||||
return written == 1 ? 0 : (written < 0 ? errno : EIO);
|
||||
return write_command(fd, OC_CMD_CANCEL);
|
||||
}
|
||||
|
||||
int vpn_write_statistics(vpn_command_handle fd)
|
||||
{
|
||||
return write_command(fd, OC_CMD_STATS);
|
||||
}
|
||||
|
||||
int vpn_collect_hip_report(const vpn_hip_script *script,
|
||||
|
||||
@@ -1,3 +1,10 @@
|
||||
#ifdef _WIN32
|
||||
#include <winsock2.h>
|
||||
#include <ws2tcpip.h>
|
||||
typedef SOCKET vpn_command_handle;
|
||||
#else
|
||||
typedef int vpn_command_handle;
|
||||
#endif
|
||||
#include <openconnect.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
@@ -13,7 +20,7 @@ typedef struct vpn_session_info {
|
||||
const char *nlb_connected_gw_ip;
|
||||
} vpn_session_info;
|
||||
|
||||
typedef void (*vpn_connected_callback)(int cmd_pipe_fd,
|
||||
typedef void (*vpn_connected_callback)(vpn_command_handle cmd_pipe_fd,
|
||||
const vpn_session_info *session_info,
|
||||
void *user_data);
|
||||
typedef void (*vpn_hip_report_callback)(void *user_data, const char *report,
|
||||
@@ -45,9 +52,12 @@ typedef struct vpn_options {
|
||||
|
||||
const char *script;
|
||||
openconnect_configure_tun_fn configure_network;
|
||||
const char *interface;
|
||||
const char *interface_name;
|
||||
const int script_tun;
|
||||
const struct openconnect_script_tun_launch *script_tun_launch;
|
||||
#ifdef _WIN32
|
||||
intptr_t script_tun_pipe;
|
||||
#endif
|
||||
|
||||
const char *certificate;
|
||||
const char *sslkey;
|
||||
@@ -73,7 +83,7 @@ extern int vpn_resolve_gateway(const char *node, const char *service,
|
||||
int vpn_collect_hip_report(const vpn_hip_script *, const struct openconnect_gp_hip_request *,
|
||||
const struct openconnect_gp_hip_control *, openconnect_gp_hip_generate_fn, void *, char *, size_t, size_t *);
|
||||
|
||||
extern int vpn_attach_command_pipe(void *user_data, int fd);
|
||||
extern int vpn_attach_command_pipe(void *user_data, vpn_command_handle fd);
|
||||
extern void vpn_detach_command_pipe(void *user_data);
|
||||
extern void vpn_script_started(void *user_data);
|
||||
enum vpn_tunnel_event {
|
||||
@@ -82,7 +92,7 @@ enum vpn_tunnel_event {
|
||||
VPN_TUNNEL_ENDED,
|
||||
};
|
||||
extern void vpn_tunnel_event(void *user_data, int event);
|
||||
extern void vpn_tunnel_configuration(void *user_data, const char *interface,
|
||||
extern void vpn_tunnel_configuration(void *user_data, const char *interface_name,
|
||||
const struct oc_ip_info *info);
|
||||
extern void vpn_tunnel_statistics(void *user_data, const struct oc_stats *stats);
|
||||
|
||||
@@ -122,8 +132,8 @@ static void _log(int level, ...)
|
||||
}
|
||||
}
|
||||
|
||||
#define LOG(level, ...) _log(level, __VA_ARGS__)
|
||||
#define ERROR(...) LOG(PRG_ERR, __VA_ARGS__)
|
||||
#define INFO(...) LOG(PRG_INFO, __VA_ARGS__)
|
||||
#define DEBUG(...) LOG(PRG_DEBUG, __VA_ARGS__)
|
||||
#define TRACE(...) LOG(PRG_TRACE, __VA_ARGS__)
|
||||
#define VPN_LOG(level, ...) _log(level, __VA_ARGS__)
|
||||
#define VPN_ERROR(...) VPN_LOG(PRG_ERR, __VA_ARGS__)
|
||||
#define VPN_INFO(...) VPN_LOG(PRG_INFO, __VA_ARGS__)
|
||||
#define VPN_DEBUG(...) VPN_LOG(PRG_DEBUG, __VA_ARGS__)
|
||||
#define VPN_TRACE(...) VPN_LOG(PRG_TRACE, __VA_ARGS__)
|
||||
@@ -1,7 +1,10 @@
|
||||
#[cfg(unix)]
|
||||
use std::os::fd::{AsRawFd, OwnedFd};
|
||||
#[cfg(windows)]
|
||||
use std::os::windows::io::{AsRawHandle, OwnedHandle};
|
||||
use std::{
|
||||
ffi::{CStr, CString, c_char},
|
||||
fmt, io,
|
||||
os::fd::{AsRawFd, OwnedFd},
|
||||
sync::{Arc, Mutex, RwLock},
|
||||
};
|
||||
|
||||
@@ -37,7 +40,8 @@ pub(crate) fn session_info_from_raw(raw: *const ffi::VpnSessionInfoRaw) -> VpnSe
|
||||
let raw = unsafe { &*raw };
|
||||
let warning_message =
|
||||
unsafe { optional_c_string(raw.lifetime_warning_message) }.filter(|message| !message.is_empty());
|
||||
let user_expires = positive_i64_to_u32(raw.user_expires).or_else(|| positive_i64_to_u32(raw.auth_expiration));
|
||||
let user_expires =
|
||||
positive_i64_to_u32(raw.user_expires.into()).or_else(|| positive_i64_to_u32(raw.auth_expiration.into()));
|
||||
|
||||
VpnSessionInfo {
|
||||
lifetime_secs: positive_i64_to_u32(raw.lifetime_secs as i64),
|
||||
@@ -73,12 +77,12 @@ struct Cancellation {
|
||||
#[derive(Default)]
|
||||
struct CancellationState {
|
||||
requested: bool,
|
||||
command_fd: Option<i32>,
|
||||
command_fd: Option<ffi::CommandHandle>,
|
||||
statistics_pending: bool,
|
||||
}
|
||||
|
||||
impl Cancellation {
|
||||
fn attach(&self, fd: i32) -> bool {
|
||||
fn attach(&self, fd: ffi::CommandHandle) -> bool {
|
||||
let mut state = self.state.lock().unwrap();
|
||||
state.command_fd = Some(fd);
|
||||
state.requested
|
||||
@@ -150,7 +154,10 @@ pub struct Vpn {
|
||||
pub(crate) network_configuration_handler: Option<Arc<NetworkConfigurationHandler>>,
|
||||
interface: Option<CString>,
|
||||
script_tun: bool,
|
||||
#[cfg(unix)]
|
||||
script_tun_launch: Option<ScriptTunLaunch>,
|
||||
#[cfg(windows)]
|
||||
script_tun_pipe: Option<OwnedHandle>,
|
||||
|
||||
certificate: Option<CString>,
|
||||
sslkey: Option<CString>,
|
||||
@@ -232,7 +239,9 @@ impl Vpn {
|
||||
}
|
||||
self.callback.write().unwrap().replace(Box::new(on_connected));
|
||||
let mut options = self.build_connect_options();
|
||||
#[cfg(unix)]
|
||||
let mut argv = Vec::new();
|
||||
#[cfg(unix)]
|
||||
let launch = self.script_tun_launch.as_ref().map(|launch| {
|
||||
argv.push(launch.program.as_ptr());
|
||||
argv.extend(launch.arguments.iter().map(|s| s.as_ptr()));
|
||||
@@ -245,7 +254,10 @@ impl Vpn {
|
||||
}
|
||||
});
|
||||
// Both the borrowed launch record and argv remain alive through native connect.
|
||||
options.script_tun_launch = launch.as_ref().map_or(std::ptr::null(), |launch| launch);
|
||||
#[cfg(unix)]
|
||||
{
|
||||
options.script_tun_launch = launch.as_ref().map_or(std::ptr::null(), |launch| launch);
|
||||
}
|
||||
let environment = match self.hip_source.as_ref() {
|
||||
HipSource::Script(script) => ffi::script_environment(script),
|
||||
_ => Vec::new(),
|
||||
@@ -269,7 +281,7 @@ impl Vpn {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn on_connected(&self, pipe_fd: i32, session_info: VpnSessionInfo) {
|
||||
pub(crate) fn on_connected(&self, pipe_fd: ffi::CommandHandle, session_info: VpnSessionInfo) {
|
||||
info!("Connected to VPN, pipe_fd: {}", pipe_fd);
|
||||
|
||||
if let Some(callback) = self.callback.write().unwrap().take() {
|
||||
@@ -277,7 +289,7 @@ impl Vpn {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn attach_command_pipe(&self, fd: i32) -> bool {
|
||||
pub(crate) fn attach_command_pipe(&self, fd: ffi::CommandHandle) -> bool {
|
||||
self.cancellation.attach(fd)
|
||||
}
|
||||
|
||||
@@ -311,9 +323,15 @@ impl Vpn {
|
||||
.network_configuration_handler
|
||||
.as_ref()
|
||||
.map(|_| ffi::configure_network as _),
|
||||
interface: Self::option_to_ptr(&self.interface),
|
||||
interface_name: Self::option_to_ptr(&self.interface),
|
||||
script_tun: self.script_tun as u32,
|
||||
script_tun_launch: std::ptr::null(),
|
||||
#[cfg(windows)]
|
||||
script_tun_pipe: self
|
||||
.script_tun_pipe
|
||||
.as_ref()
|
||||
.map(|handle| handle.as_raw_handle() as isize)
|
||||
.unwrap_or(-1),
|
||||
|
||||
certificate: Self::option_to_ptr(&self.certificate),
|
||||
sslkey: Self::option_to_ptr(&self.sslkey),
|
||||
@@ -366,6 +384,7 @@ impl fmt::Display for VpnError {
|
||||
|
||||
impl std::error::Error for VpnError {}
|
||||
|
||||
#[cfg(unix)]
|
||||
struct ScriptTunLaunch {
|
||||
program: CString,
|
||||
arguments: Vec<CString>,
|
||||
@@ -381,7 +400,10 @@ pub struct VpnBuilder {
|
||||
script_is_path: bool,
|
||||
interface: Option<String>,
|
||||
script_tun: bool,
|
||||
#[cfg(unix)]
|
||||
script_tun_launch: Option<ScriptTunLaunch>,
|
||||
#[cfg(windows)]
|
||||
script_tun_pipe: Option<OwnedHandle>,
|
||||
|
||||
user_agent: Option<String>,
|
||||
os: Option<String>,
|
||||
@@ -416,7 +438,10 @@ impl VpnBuilder {
|
||||
script_is_path: false,
|
||||
interface: None,
|
||||
script_tun: false,
|
||||
#[cfg(unix)]
|
||||
script_tun_launch: None,
|
||||
#[cfg(windows)]
|
||||
script_tun_pipe: None,
|
||||
|
||||
user_agent: None,
|
||||
os: None,
|
||||
@@ -469,6 +494,7 @@ impl VpnBuilder {
|
||||
self
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
pub fn script_tun_program(
|
||||
mut self,
|
||||
program: &str,
|
||||
@@ -495,6 +521,19 @@ impl VpnBuilder {
|
||||
Ok(self)
|
||||
}
|
||||
|
||||
/// Deliver packets through a connected Windows message-mode pipe.
|
||||
///
|
||||
/// # Safety
|
||||
/// The handle must use overlapped I/O and must not be associated with an IOCP.
|
||||
/// OpenConnect duplicates it and owns its own completion events; attaching a
|
||||
/// Tokio/Mio handle would send native OVERLAPPED completions into that reactor.
|
||||
#[cfg(windows)]
|
||||
pub unsafe fn script_tun_pipe(mut self, pipe: OwnedHandle) -> Self {
|
||||
self.script_tun = true;
|
||||
self.script_tun_pipe = Some(pipe);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn script_tun(mut self, script_tun: bool) -> Self {
|
||||
self.script_tun = script_tun;
|
||||
self
|
||||
@@ -596,9 +635,17 @@ impl VpnBuilder {
|
||||
}
|
||||
return Ok(None);
|
||||
}
|
||||
#[cfg(unix)]
|
||||
if self.script_tun_launch.is_some() {
|
||||
return Ok(None);
|
||||
}
|
||||
#[cfg(windows)]
|
||||
if self.script_tun_pipe.is_some() {
|
||||
if self.script.is_some() || !self.script_tun {
|
||||
return Err(VpnError::new("Packet pipe conflicts with script options".into()));
|
||||
}
|
||||
return Ok(None);
|
||||
}
|
||||
let script = match &self.script {
|
||||
Some(script) => {
|
||||
if self.script_is_path && !std::path::Path::new(script).exists() {
|
||||
@@ -618,6 +665,7 @@ impl VpnBuilder {
|
||||
}
|
||||
|
||||
pub fn build(self) -> Result<Vpn, VpnError> {
|
||||
#[cfg(unix)]
|
||||
if self.script_tun_launch.is_some() && !self.script_tun {
|
||||
return Err(VpnError::new("Child identity requires script-tun".into()));
|
||||
}
|
||||
@@ -642,7 +690,10 @@ impl VpnBuilder {
|
||||
network_configuration_handler: self.network_configuration_handler,
|
||||
interface: self.interface.as_deref().map(Self::to_cstring),
|
||||
script_tun: self.script_tun,
|
||||
#[cfg(unix)]
|
||||
script_tun_launch: self.script_tun_launch,
|
||||
#[cfg(windows)]
|
||||
script_tun_pipe: self.script_tun_pipe,
|
||||
|
||||
certificate: self.certificate.as_deref().map(Self::to_cstring),
|
||||
sslkey: self.sslkey.as_deref().map(Self::to_cstring),
|
||||
@@ -774,7 +825,10 @@ mod tests {
|
||||
network_configuration_handler: None,
|
||||
interface: None,
|
||||
script_tun: false,
|
||||
#[cfg(unix)]
|
||||
script_tun_launch: None,
|
||||
#[cfg(windows)]
|
||||
script_tun_pipe: None,
|
||||
certificate: None,
|
||||
sslkey: None,
|
||||
key_password: None,
|
||||
@@ -1078,6 +1132,7 @@ mod tests {
|
||||
}
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
#[cfg(unix)]
|
||||
extern "C" fn vpn_script_started(data: *mut std::ffi::c_void) {
|
||||
// Native setup has forked or failed; only the child may retain this endpoint.
|
||||
let vpn = unsafe { &*(data as *const Vpn) };
|
||||
|
||||
@@ -0,0 +1,169 @@
|
||||
/* Exercise the DLL's packet mainloop without a VPN server or kernel adapter. */
|
||||
#include "config.h"
|
||||
#include "openconnect-internal.h"
|
||||
#include <assert.h>
|
||||
|
||||
struct test_context {
|
||||
wchar_t name[128];
|
||||
SOCKET command;
|
||||
int mode, seeded;
|
||||
volatile LONG statistics;
|
||||
};
|
||||
static void progress(void *data, int level, const char *format, ...)
|
||||
{
|
||||
(void)data; (void)level; (void)format;
|
||||
}
|
||||
static void statistics(void *data, const struct oc_stats *stats)
|
||||
{
|
||||
struct test_context *context = data;
|
||||
(void)stats;
|
||||
InterlockedIncrement(&context->statistics);
|
||||
}
|
||||
static int pump(struct openconnect_info *vpninfo, int *timeout, int readable)
|
||||
{
|
||||
struct test_context *context = vpninfo->cbdata;
|
||||
struct pkt *packet;
|
||||
int work = 0;
|
||||
(void)timeout; (void)readable;
|
||||
vpninfo->need_poll_cmd_fd = 1;
|
||||
while ((packet = dequeue_packet(&vpninfo->outgoing_queue))) {
|
||||
queue_packet(&vpninfo->incoming_queue, packet);
|
||||
work = 1;
|
||||
}
|
||||
if (context->mode == 2 && !context->seeded) {
|
||||
int index;
|
||||
context->seeded = 1;
|
||||
for (index = 0; index < 32; index++) {
|
||||
packet = calloc(1, sizeof(*packet) + 1500);
|
||||
assert(packet);
|
||||
packet->len = 1500;
|
||||
memset(packet->data, index, packet->len);
|
||||
queue_packet(&vpninfo->incoming_queue, packet);
|
||||
}
|
||||
work = 1;
|
||||
}
|
||||
return work;
|
||||
}
|
||||
static const struct vpn_proto protocol = { .name = "packet-test", .tcp_mainloop = pump };
|
||||
static DWORD WINAPI client(void *data)
|
||||
{
|
||||
struct test_context *context = data;
|
||||
HANDLE pipe = CreateFileW(context->name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
|
||||
OPEN_EXISTING, 0, NULL);
|
||||
DWORD mode = PIPE_READMODE_MESSAGE, count;
|
||||
char bytes[1024], response[1024], command;
|
||||
assert(pipe != INVALID_HANDLE_VALUE);
|
||||
assert(SetNamedPipeHandleState(pipe, &mode, NULL, NULL));
|
||||
if (context->mode == 0) {
|
||||
int index;
|
||||
for (index = 0; index < 2; index++) {
|
||||
DWORD length = 257 + index * 97;
|
||||
memset(bytes, 'a' + index, length);
|
||||
assert(WriteFile(pipe, bytes, length, &count, NULL) && count == length);
|
||||
assert(ReadFile(pipe, response, sizeof(response), &count, NULL) && count == length);
|
||||
assert(!memcmp(bytes, response, length));
|
||||
}
|
||||
} else if (context->mode == 3) {
|
||||
/* Free before mainloop must close the duplicate and drain its read. */
|
||||
assert(!ReadFile(pipe, response, sizeof(response), &count, NULL));
|
||||
assert(GetLastError() == ERROR_BROKEN_PIPE);
|
||||
} else {
|
||||
/* No reads: mode 2 fills the service-to-worker packet buffer. */
|
||||
Sleep(100);
|
||||
command = OC_CMD_STATS;
|
||||
assert(send(context->command, &command, 1, 0) == 1);
|
||||
Sleep(100);
|
||||
command = OC_CMD_CANCEL;
|
||||
assert(send(context->command, &command, 1, 0) == 1);
|
||||
Sleep(100);
|
||||
}
|
||||
CloseHandle(pipe);
|
||||
return 0;
|
||||
}
|
||||
static DWORD WINAPI watchdog(void *event)
|
||||
{
|
||||
if (WaitForSingleObject(event, 15000) == WAIT_TIMEOUT) {
|
||||
fputs("FAIL: packet pipe test timed out\n", stderr);
|
||||
ExitProcess(99);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
static void run(int mode)
|
||||
{
|
||||
struct test_context context = { .mode = mode };
|
||||
struct openconnect_info *vpninfo;
|
||||
HANDLE pipe, thread, event;
|
||||
OVERLAPPED connected = { 0 };
|
||||
DWORD count;
|
||||
ULONGLONG started;
|
||||
int result;
|
||||
swprintf(context.name, 128, L"\\\\.\\pipe\\GPConnect.NativePacketTest.%lu.%d", GetCurrentProcessId(), mode);
|
||||
pipe = CreateNamedPipeW(context.name, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE,
|
||||
PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_REJECT_REMOTE_CLIENTS, 1, 4096, 4096, 0, NULL);
|
||||
assert(pipe != INVALID_HANDLE_VALUE);
|
||||
vpninfo = openconnect_vpninfo_new("packet-test", NULL, NULL, NULL, progress, &context);
|
||||
assert(vpninfo);
|
||||
context.command = openconnect_setup_cmd_pipe(vpninfo);
|
||||
assert(context.command != INVALID_SOCKET);
|
||||
vpninfo->proto = &protocol;
|
||||
vpninfo->dtls_state = DTLS_DISABLED;
|
||||
vpninfo->ip_info.mtu = 1500;
|
||||
openconnect_set_stats_handler(vpninfo, statistics);
|
||||
thread = CreateThread(NULL, 0, client, &context, 0, NULL);
|
||||
assert(thread);
|
||||
event = CreateEvent(NULL, TRUE, FALSE, NULL);
|
||||
assert(event);
|
||||
connected.hEvent = event;
|
||||
if (!ConnectNamedPipe(pipe, &connected)) {
|
||||
DWORD error = GetLastError();
|
||||
if (error != ERROR_PIPE_CONNECTED) {
|
||||
assert(error == ERROR_IO_PENDING);
|
||||
assert(GetOverlappedResult(pipe, &connected, &count, TRUE));
|
||||
}
|
||||
}
|
||||
CloseHandle(event);
|
||||
assert(!openconnect_setup_tun_pipe(vpninfo, (intptr_t)pipe));
|
||||
assert(vpninfo->tun_is_pipe && vpninfo->tun_fh != pipe);
|
||||
CloseHandle(pipe);
|
||||
started = GetTickCount64();
|
||||
if (mode == 3) {
|
||||
vpninfo->tun_pkt = calloc(1, sizeof(struct pkt) + 1500);
|
||||
assert(vpninfo->tun_pkt);
|
||||
assert(!ReadFile(vpninfo->tun_fh, vpninfo->tun_pkt->data, 1500, &count, &vpninfo->tun_rd_overlap));
|
||||
assert(GetLastError() == ERROR_IO_PENDING);
|
||||
vpninfo->tun_rd_pending = 1;
|
||||
openconnect_vpninfo_free(vpninfo);
|
||||
} else {
|
||||
result = openconnect_mainloop(vpninfo, 1, 1);
|
||||
assert(result < 0);
|
||||
assert(vpninfo->tun_fh == INVALID_HANDLE_VALUE && !vpninfo->tun_rd_pending);
|
||||
assert(!vpninfo->tun_rd_overlap.hEvent && !vpninfo->tun_wr_overlap.hEvent);
|
||||
if (mode) {
|
||||
assert(GetTickCount64() - started < 3000);
|
||||
assert(context.statistics == 1);
|
||||
if (mode == 2)
|
||||
assert(vpninfo->stats.rx_pkts > 0 && vpninfo->stats.rx_pkts < 32);
|
||||
} else {
|
||||
assert(vpninfo->stats.rx_pkts == 2 && vpninfo->stats.tx_pkts == 2);
|
||||
}
|
||||
openconnect_vpninfo_free(vpninfo);
|
||||
}
|
||||
assert(WaitForSingleObject(thread, 2000) == WAIT_OBJECT_0);
|
||||
CloseHandle(thread);
|
||||
printf("PASS: native packet pipe case %d\n", mode);
|
||||
}
|
||||
int main(void)
|
||||
{
|
||||
HANDLE stop = CreateEvent(NULL, TRUE, FALSE, NULL);
|
||||
HANDLE guard = CreateThread(NULL, 0, watchdog, stop, 0, NULL);
|
||||
int mode;
|
||||
assert(stop && guard);
|
||||
assert(!openconnect_init_ssl());
|
||||
for (mode = 0; mode < 4; mode++)
|
||||
run(mode);
|
||||
SetEvent(stop);
|
||||
WaitForSingleObject(guard, 1000);
|
||||
CloseHandle(guard);
|
||||
CloseHandle(stop);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
# Windows installer
|
||||
|
||||
`installer.nsi` embeds a complete Windows payload and the canonical
|
||||
`machine-install.ps1` installation implementation. Build it with NSIS 3 Unicode:
|
||||
|
||||
```powershell
|
||||
& makensis /DTARGET_ARCH=x64 /DPAYLOAD_DIR=C:\build\payload /DOUTPUT_FILE=C:\build\GPConnect-Setup.exe /DPRODUCT_VERSION=3.4.0 /DBUILD_VERSION=3.4.0.0 /DDISPLAY_VERSION=3.4.0-snapshot.2026.1114.2 .\packaging\windows\installer.nsi
|
||||
```
|
||||
|
||||
`TARGET_ARCH` is `x64` or `arm64` and must match every executable and DLL in
|
||||
the payload. Each installer accepts only its native Windows architecture. ARM64
|
||||
requires Windows 11; x64 requires Windows 10 build 19041 or newer.
|
||||
|
||||
`BUILD_VERSION` must contain four numeric components. `PRODUCT_VERSION` must
|
||||
match the payload's `build-info.json`. `DISPLAY_VERSION` is the full release
|
||||
identity, including the snapshot build when applicable. The payload must contain matching
|
||||
`gpgui.exe`, `gpauth.exe`, `gpservice.exe`, their DLL dependency closure, the
|
||||
vendor-signed `wintun.dll`, `licenses`, and `build-info.json`. The NSIS compiler
|
||||
adds the generated uninstaller; it is not a separately built executable.
|
||||
|
||||
The installer, extraction progress and uninstaller use the shared Windows icon
|
||||
from `apps/gpauth/icons/windows/icon.ico`. The Finish page uses `sidebar.bmp`,
|
||||
derived from that same icon. After regenerating application icons, run
|
||||
`powershell -NoProfile -File scripts/generate-windows-installer-artwork.ps1`
|
||||
on Windows and retain the updated bitmap before building installers.
|
||||
|
||||
The development ZIP includes the same machine implementation as
|
||||
`installer/machine-install.ps1`. Its install/uninstall entrypoints call that
|
||||
implementation rather than maintaining a second file replacement algorithm.
|
||||
Use the EXE installer to upgrade an installation that already has an NSIS
|
||||
uninstaller; the development ZIP does not contain that generated executable.
|
||||
|
||||
Installation waits for the installed GUI/auth paths in all Windows sessions;
|
||||
it does not stop arbitrary same-name processes. Service shutdown uses SCM,
|
||||
checks the existing network-recovery criteria, and waits for file release.
|
||||
Application files are staged under Program Files with protected ACLs. The old
|
||||
directory is renamed to `GP Connect.previous` until the new service is Running.
|
||||
Handled replacement/start failures restore old files and metadata and restart
|
||||
the previous service. An interrupted installer with a retained backup requires
|
||||
explicit repair; it is not automatically recovered.
|
||||
|
||||
Disk use includes the downloaded installer and one expanded new payload. NSIS
|
||||
extracts into its temporary directory, then the machine implementation consumes
|
||||
those disposable files into protected staging instead of copying the whole bundle.
|
||||
When temp and Program Files use different volumes, file moves may temporarily
|
||||
duplicate the file currently being moved. The old installation is renamed, not
|
||||
copied. The machine implementation checks the installation volume before staging;
|
||||
NSIS extraction errors must complete before service shutdown.
|
||||
Successful installation removes the old copy and staging. Installer logs keep
|
||||
the current and previous attempt in ProgramData. No updater cache is added.
|
||||
|
||||
The installer never launches the GUI as administrator. Users open GP Connect
|
||||
from the Start menu after completion. User configuration and licensing state
|
||||
are retained during upgrades and uninstall. Authenticode setup is separate;
|
||||
WinSparkle must still verify the installer payload signature before handoff.
|
||||
|
||||
The service log rotates after 5 MiB and retains three numbered archives, keeping
|
||||
each entry whole. The bundle includes `licenses/file-rotate.txt` for the Windows
|
||||
service's rotation library.
|
||||
|
||||
On a disposable Windows installation, verify a normal A-to-B upgrade and a B
|
||||
payload whose `gpservice.exe` is replaced with another valid PE executable that
|
||||
cannot host a Windows service. The latter must fail service startup, restore A's
|
||||
files and uninstall metadata, and leave A's service running. Also check held
|
||||
runtime files, active GUI/auth windows, Wintun-signature failure, and concurrent
|
||||
installer attempts. Do not run failure fixtures against a live company VPN.
|
||||
@@ -0,0 +1,97 @@
|
||||
Unicode true
|
||||
RequestExecutionLevel admin
|
||||
!include "MUI2.nsh"
|
||||
!include "x64.nsh"
|
||||
|
||||
!ifndef PAYLOAD_DIR
|
||||
!error "PAYLOAD_DIR is required"
|
||||
!endif
|
||||
!ifndef OUTPUT_FILE
|
||||
!error "OUTPUT_FILE is required"
|
||||
!endif
|
||||
!ifndef PRODUCT_VERSION
|
||||
!error "PRODUCT_VERSION is required"
|
||||
!endif
|
||||
!ifndef TARGET_ARCH
|
||||
!define TARGET_ARCH "x64"
|
||||
!endif
|
||||
!ifndef BUILD_VERSION
|
||||
!define BUILD_VERSION "${PRODUCT_VERSION}.0"
|
||||
!endif
|
||||
!ifndef DISPLAY_VERSION
|
||||
!define DISPLAY_VERSION "${PRODUCT_VERSION}"
|
||||
!endif
|
||||
|
||||
Name "GP Connect"
|
||||
OutFile "${OUTPUT_FILE}"
|
||||
InstallDir "$PROGRAMFILES64\GP Connect"
|
||||
VIProductVersion "${BUILD_VERSION}"
|
||||
VIAddVersionKey "ProductName" "GP Connect"
|
||||
VIAddVersionKey "FileDescription" "GP Connect Installer"
|
||||
VIAddVersionKey "ProductVersion" "${DISPLAY_VERSION}"
|
||||
VIAddVersionKey "FileVersion" "${BUILD_VERSION}"
|
||||
VIAddVersionKey "LegalCopyright" "GP Connect contributors"
|
||||
ShowInstDetails show
|
||||
ShowUninstDetails show
|
||||
!define MUI_ICON "${__FILEDIR__}\..\..\apps\gpauth\icons\windows\icon.ico"
|
||||
!define MUI_UNICON "${MUI_ICON}"
|
||||
!define MUI_WELCOMEFINISHPAGE_BITMAP "${__FILEDIR__}\sidebar.bmp"
|
||||
!define MUI_ABORTWARNING
|
||||
!define MUI_FINISHPAGE_TITLE "GP Connect is ready"
|
||||
!define MUI_FINISHPAGE_TEXT "Open GP Connect from the Start menu."
|
||||
!insertmacro MUI_PAGE_INSTFILES
|
||||
!insertmacro MUI_PAGE_FINISH
|
||||
!insertmacro MUI_UNPAGE_CONFIRM
|
||||
!insertmacro MUI_UNPAGE_INSTFILES
|
||||
!insertmacro MUI_LANGUAGE "English"
|
||||
|
||||
Function .onInit
|
||||
!if "${TARGET_ARCH}" == "arm64"
|
||||
${IfNot} ${IsNativeARM64}
|
||||
MessageBox MB_OK|MB_ICONSTOP "This GP Connect installer requires Windows 11 on ARM64." /SD IDOK
|
||||
SetErrorLevel 1
|
||||
Abort
|
||||
${EndIf}
|
||||
!else if "${TARGET_ARCH}" == "x64"
|
||||
${IfNot} ${IsNativeAMD64}
|
||||
MessageBox MB_OK|MB_ICONSTOP "This GP Connect installer requires x64 Windows." /SD IDOK
|
||||
SetErrorLevel 1
|
||||
Abort
|
||||
${EndIf}
|
||||
!else
|
||||
!error "Unsupported TARGET_ARCH"
|
||||
!endif
|
||||
SetRegView 64
|
||||
FunctionEnd
|
||||
|
||||
Section "Install"
|
||||
InitPluginsDir
|
||||
SetOutPath "$PLUGINSDIR\payload"
|
||||
File /r "${PAYLOAD_DIR}\*"
|
||||
WriteUninstaller "$PLUGINSDIR\payload\uninstall.exe"
|
||||
SetOutPath "$PLUGINSDIR"
|
||||
File "${__FILEDIR__}\machine-install.ps1"
|
||||
DetailPrint "Preparing GP Connect and waiting for open windows to close..."
|
||||
nsExec::ExecToLog '"$WINDIR\Sysnative\WindowsPowerShell\v1.0\powershell.exe" -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "$PLUGINSDIR\machine-install.ps1" -Action Install -SourceDirectory "$PLUGINSDIR\payload" -Version "${PRODUCT_VERSION}" -ConsumeSource'
|
||||
Pop $0
|
||||
${If} $0 != 0
|
||||
MessageBox MB_OK|MB_ICONSTOP "GP Connect could not be installed. See the details below and try again." /SD IDOK
|
||||
SetErrorLevel 1
|
||||
Abort
|
||||
${EndIf}
|
||||
SectionEnd
|
||||
|
||||
Section "Uninstall"
|
||||
SetRegView 64
|
||||
InitPluginsDir
|
||||
SetOutPath "$PLUGINSDIR"
|
||||
File "${__FILEDIR__}\machine-install.ps1"
|
||||
DetailPrint "Waiting for GP Connect and sign-in windows to close..."
|
||||
nsExec::ExecToLog '"$WINDIR\Sysnative\WindowsPowerShell\v1.0\powershell.exe" -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "$PLUGINSDIR\machine-install.ps1" -Action Uninstall'
|
||||
Pop $0
|
||||
${If} $0 != 0
|
||||
MessageBox MB_OK|MB_ICONSTOP "GP Connect could not be removed. See the details below and try again." /SD IDOK
|
||||
SetErrorLevel 1
|
||||
Abort
|
||||
${EndIf}
|
||||
SectionEnd
|
||||
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2020 BourgondAries
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,383 @@
|
||||
#Requires -RunAsAdministrator
|
||||
[CmdletBinding()]
|
||||
param(
|
||||
[Parameter(Mandatory=$true)][ValidateSet('Install', 'Uninstall')][string]$Action,
|
||||
[string]$SourceDirectory,
|
||||
[string]$Version,
|
||||
[switch]$ConsumeSource
|
||||
)
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$ProgressPreference = 'SilentlyContinue'
|
||||
if ($PSVersionTable.PSEdition -eq 'Desktop') {
|
||||
# A PowerShell 7 caller can pass incompatible modules to Windows PowerShell.
|
||||
$env:PSModulePath = Join-Path $PSHOME 'Modules'
|
||||
}
|
||||
if (![Environment]::Is64BitProcess) { throw 'Run the GP Connect installer with 64-bit PowerShell.' }
|
||||
$destination = Join-Path ([Environment]::GetFolderPath('ProgramFiles')) 'GP Connect'
|
||||
$state = Join-Path $env:ProgramData 'GP Connect'
|
||||
$serviceName = 'GPConnect'
|
||||
$serviceBinary = Join-Path $destination 'gpservice.exe'
|
||||
$shortcutPath = Join-Path $env:ProgramData 'Microsoft\Windows\Start Menu\Programs\GP Connect.lnk'
|
||||
$uninstallKey = 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\GPConnect'
|
||||
$recoveryKey = 'HKLM:\SOFTWARE\GP Connect\NetworkRecovery'
|
||||
$publicAcl = 'O:BAG:BAD:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FRFX;;;BU)'
|
||||
$privateAcl = 'O:BAG:BAD:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)'
|
||||
$backup = $destination + '.previous'
|
||||
$stage = $null
|
||||
$oldMoved = $false
|
||||
$newMoved = $false
|
||||
$serviceStopped = $false
|
||||
$createdService = $false
|
||||
$committed = $false
|
||||
$oldMetadata = $null
|
||||
$oldShortcut = $null
|
||||
|
||||
function Assert-RegularDirectory([string]$Path) {
|
||||
if (Test-Path -LiteralPath $Path) {
|
||||
$item = Get-Item -LiteralPath $Path -Force
|
||||
if (!$item.PSIsContainer -or ($item.Attributes -band [IO.FileAttributes]::ReparsePoint)) {
|
||||
throw "The installation folder must be a regular directory: $Path"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function Set-DirectoryAcl([string]$Path, [string]$Descriptor) {
|
||||
Assert-RegularDirectory $Path
|
||||
if (!(Test-Path -LiteralPath $Path)) { New-Item -ItemType Directory -Path $Path | Out-Null }
|
||||
$acl = Get-Acl -LiteralPath $Path
|
||||
$acl.SetSecurityDescriptorSddlForm($Descriptor)
|
||||
Set-Acl -LiteralPath $Path -AclObject $acl
|
||||
}
|
||||
|
||||
function Wait-ForApplications {
|
||||
$deadline = [DateTime]::UtcNow.AddSeconds(30)
|
||||
do {
|
||||
$running = @(Get-CimInstance Win32_Process -Filter "Name='gpgui.exe' OR Name='gpauth.exe'" |
|
||||
Where-Object { $_.ExecutablePath -in @((Join-Path $destination 'gpgui.exe'), (Join-Path $destination 'gpauth.exe')) })
|
||||
if (!$running.Count) { return }
|
||||
if ([DateTime]::UtcNow -ge $deadline) {
|
||||
throw 'Quit GP Connect and finish or cancel sign-in in all Windows sessions, then try again.'
|
||||
}
|
||||
Start-Sleep -Milliseconds 250
|
||||
} while ($true)
|
||||
}
|
||||
|
||||
function Wait-ServiceState([string]$Expected) {
|
||||
$controller = Get-Service -Name $serviceName
|
||||
try { $controller.WaitForStatus($Expected, [TimeSpan]::FromSeconds(30)) }
|
||||
finally { $controller.Dispose() }
|
||||
}
|
||||
|
||||
function Stop-InstalledService {
|
||||
$service = Get-Service -Name $serviceName -ErrorAction SilentlyContinue
|
||||
if (!$service) { return }
|
||||
try { $stopped = $service.Status -eq 'Stopped' } finally { $service.Dispose() }
|
||||
if (!$stopped) { Stop-Service -Name $serviceName; Wait-ServiceState 'Stopped' }
|
||||
}
|
||||
|
||||
function Start-InstalledService {
|
||||
Start-Service -Name $serviceName
|
||||
Wait-ServiceState 'Running'
|
||||
}
|
||||
|
||||
function Move-InstalledDirectoryToBackup {
|
||||
try { Move-Item -LiteralPath $destination -Destination $backup }
|
||||
catch [IO.IOException] {
|
||||
throw 'GP Connect files are in use. Close any GP Connect folders in File Explorer and try again.'
|
||||
}
|
||||
}
|
||||
|
||||
function Wait-ForRuntimeRelease {
|
||||
$deadline = [DateTime]::UtcNow.AddSeconds(30)
|
||||
do {
|
||||
$locked = $false
|
||||
foreach ($file in Get-ChildItem -LiteralPath $destination -File | Where-Object { $_.Extension -in @('.exe', '.dll') }) {
|
||||
try {
|
||||
$stream = [IO.File]::Open($file.FullName, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::None)
|
||||
$stream.Dispose()
|
||||
} catch [IO.IOException] { $locked = $true; break }
|
||||
}
|
||||
if (!$locked) { return }
|
||||
if ([DateTime]::UtcNow -ge $deadline) { throw 'An application file is still in use. Close GP Connect in all Windows sessions and try again.' }
|
||||
Start-Sleep -Milliseconds 250
|
||||
} while ($true)
|
||||
}
|
||||
|
||||
function Assert-NetworkClean {
|
||||
$records = @()
|
||||
if (Test-Path $recoveryKey) { $records = @((Get-Item $recoveryKey).GetValueNames() | Where-Object { $_ -like 'Route-*' }) }
|
||||
$policies = @(Get-DnsClientNrptRule | Where-Object { $_.Comment -like 'GPConnect:*' })
|
||||
if ($records.Count -or $policies.Count) {
|
||||
throw 'VPN network cleanup is incomplete. Restart GP Connect before trying again.'
|
||||
}
|
||||
}
|
||||
|
||||
function Invoke-ServiceCommand([string[]]$Arguments) {
|
||||
& "$env:SystemRoot\System32\sc.exe" @Arguments | Out-Null
|
||||
if ($LASTEXITCODE -ne 0) { throw "Windows service configuration failed ($LASTEXITCODE)." }
|
||||
}
|
||||
|
||||
function Set-MachineState {
|
||||
Set-DirectoryAcl $state $publicAcl
|
||||
Set-DirectoryAcl (Join-Path $state 'Private') $privateAcl
|
||||
foreach ($name in @('gpservice.lock', 'gpservice.log')) {
|
||||
$path = Join-Path $state $name
|
||||
if (Test-Path -LiteralPath $path) {
|
||||
if ((Get-Item -LiteralPath $path -Force).Attributes -band [IO.FileAttributes]::ReparsePoint) {
|
||||
throw "Service state file must not be a link: $path"
|
||||
}
|
||||
$acl = Get-Acl -LiteralPath $path
|
||||
$acl.SetSecurityDescriptorSddlForm($publicAcl)
|
||||
Set-Acl -LiteralPath $path -AclObject $acl
|
||||
}
|
||||
}
|
||||
$registry = [Microsoft.Win32.Registry]::LocalMachine.CreateSubKey('SOFTWARE\GP Connect')
|
||||
try {
|
||||
$recovery = $registry.CreateSubKey('NetworkRecovery', [Microsoft.Win32.RegistryKeyPermissionCheck]::ReadWriteSubTree, [Microsoft.Win32.RegistryOptions]::Volatile)
|
||||
try {
|
||||
foreach ($key in @($registry, $recovery)) {
|
||||
$acl = New-Object System.Security.AccessControl.RegistrySecurity
|
||||
$acl.SetSecurityDescriptorSddlForm('O:BAG:BAD:P(A;CI;KA;;;SY)(A;CI;KA;;;BA)')
|
||||
$key.SetAccessControl($acl)
|
||||
}
|
||||
} finally { $recovery.Dispose() }
|
||||
} finally { $registry.Dispose() }
|
||||
}
|
||||
|
||||
function Set-InstallationMetadata([string]$InstalledVersion) {
|
||||
$shell = New-Object -ComObject WScript.Shell
|
||||
$shortcut = $shell.CreateShortcut($shortcutPath)
|
||||
$shortcut.TargetPath = Join-Path $destination 'gpgui.exe'
|
||||
$shortcut.WorkingDirectory = $destination
|
||||
$shortcut.Description = 'GP Connect'
|
||||
$shortcut.IconLocation = (Join-Path $destination 'gpgui.exe') + ',0'
|
||||
$shortcut.Save()
|
||||
if (Test-Path -LiteralPath (Join-Path $destination 'uninstall.exe')) {
|
||||
New-Item -Path $uninstallKey -Force | Out-Null
|
||||
$values = @{
|
||||
DisplayName = 'GP Connect'; DisplayVersion = $InstalledVersion; Publisher = 'GP Connect'
|
||||
InstallLocation = $destination; DisplayIcon = (Join-Path $destination 'gpgui.exe')
|
||||
UninstallString = '"' + (Join-Path $destination 'uninstall.exe') + '"'
|
||||
}
|
||||
foreach ($entry in $values.GetEnumerator()) {
|
||||
New-ItemProperty -Path $uninstallKey -Name $entry.Key -Value $entry.Value -PropertyType String -Force | Out-Null
|
||||
}
|
||||
foreach ($name in @('NoModify', 'NoRepair')) {
|
||||
New-ItemProperty -Path $uninstallKey -Name $name -Value 1 -PropertyType DWord -Force | Out-Null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function Restore-InstallationMetadata {
|
||||
if (Test-Path $uninstallKey) { Remove-Item $uninstallKey -Recurse -Force }
|
||||
if ($oldMetadata) {
|
||||
New-Item -Path $uninstallKey -Force | Out-Null
|
||||
foreach ($entry in $oldMetadata.GetEnumerator()) {
|
||||
New-ItemProperty -Path $uninstallKey -Name $entry.Key -Value $entry.Value.Value -PropertyType $entry.Value.Kind -Force | Out-Null
|
||||
}
|
||||
}
|
||||
if ($oldShortcut) { [IO.File]::WriteAllBytes($shortcutPath, $oldShortcut) }
|
||||
elseif (Test-Path -LiteralPath $shortcutPath) { Remove-Item -LiteralPath $shortcutPath -Force }
|
||||
}
|
||||
|
||||
function Remove-OwnedCallback {
|
||||
$callback = 'HKCU:\Software\Classes\globalprotectcallback'
|
||||
$commandKey = "$callback\shell\open\command"
|
||||
if (Test-Path $commandKey) {
|
||||
$command = (Get-Item $commandKey).GetValue('')
|
||||
$authBinary = Join-Path $destination 'gpauth.exe'
|
||||
$owned = @("`"$authBinary`" auth-callback `"%1`"", "`"\\?\$authBinary`" auth-callback `"%1`"")
|
||||
if ($command -in $owned) { Remove-Item $callback -Recurse -Force }
|
||||
}
|
||||
}
|
||||
|
||||
$mutex = New-Object System.Threading.Mutex($false, 'Global\GPConnect.Installer')
|
||||
$owned = $false
|
||||
$transcript = $false
|
||||
try {
|
||||
try { $owned = $mutex.WaitOne(0) } catch [Threading.AbandonedMutexException] { $owned = $true }
|
||||
if (!$owned) { throw 'Another GP Connect installation is running. Wait for it to finish.' }
|
||||
Assert-RegularDirectory $destination
|
||||
Assert-RegularDirectory $state
|
||||
if (Test-Path -LiteralPath $backup) {
|
||||
throw "A previous installation needs repair. The retained files are in $backup. Do not delete them before restoring GP Connect."
|
||||
}
|
||||
# Keep only this attempt and one previous diagnostic log.
|
||||
Set-DirectoryAcl $state $publicAcl
|
||||
$log = Join-Path $state 'installer.log'
|
||||
$previousLog = Join-Path $state 'installer.previous.log'
|
||||
foreach ($path in @($log, $previousLog)) {
|
||||
if ((Test-Path -LiteralPath $path) -and ((Get-Item -LiteralPath $path -Force).Attributes -band [IO.FileAttributes]::ReparsePoint)) {
|
||||
throw 'Installer log must not be a link.'
|
||||
}
|
||||
}
|
||||
if (Test-Path -LiteralPath $previousLog) { Remove-Item -LiteralPath $previousLog -Force }
|
||||
if (Test-Path -LiteralPath $log) { Move-Item -LiteralPath $log -Destination $previousLog }
|
||||
Start-Transcript -Path $log -Force | Out-Null
|
||||
$transcript = $true
|
||||
$existing = Get-CimInstance Win32_Service -Filter "Name='$serviceName'"
|
||||
if ($existing -and $existing.PathName -ne ('"' + $serviceBinary + '"')) {
|
||||
throw 'The GPConnect service is registered to another installation.'
|
||||
}
|
||||
$wasRunning = $existing -and $existing.State -ne 'Stopped'
|
||||
|
||||
if ($Action -eq 'Install') {
|
||||
if (!$SourceDirectory) { throw 'An installation source is required.' }
|
||||
$source = (Resolve-Path -LiteralPath $SourceDirectory).Path.TrimEnd('\')
|
||||
if ($source -eq $destination -or $source.StartsWith($destination + '\', [StringComparison]::OrdinalIgnoreCase)) {
|
||||
throw 'Install from an extracted package outside the application folder.'
|
||||
}
|
||||
foreach ($name in @('gpservice.exe', 'gpauth.exe', 'gpgui.exe', 'libopenconnect-5.dll', 'wintun.dll', 'build-info.json')) {
|
||||
if (!(Test-Path -LiteralPath (Join-Path $source $name) -PathType Leaf)) { throw "Missing Windows package file: $name" }
|
||||
}
|
||||
$info = Get-Content -LiteralPath (Join-Path $source 'build-info.json') -Raw | ConvertFrom-Json
|
||||
if ((Test-Path -LiteralPath (Join-Path $destination 'uninstall.exe')) -and
|
||||
!(Test-Path -LiteralPath (Join-Path $source 'uninstall.exe'))) {
|
||||
throw 'Use the Windows installer to update this installation.'
|
||||
}
|
||||
if (!$Version) { $Version = $info.version }
|
||||
$architecture = [System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture.ToString().ToLowerInvariant()
|
||||
if ($info.product -ne 'GP Connect' -or $info.architecture -notin @('x64','arm64') -or $info.architecture -ne $architecture -or !$Version -or $info.version -ne $Version) {
|
||||
throw 'The package version or architecture does not match this installer.'
|
||||
}
|
||||
if (![Environment]::Is64BitProcess -or [Environment]::OSVersion.Version.Build -lt 19041) {
|
||||
throw 'GP Connect requires Windows 10 build 19041 or newer.'
|
||||
}
|
||||
if ($architecture -eq 'arm64' -and [Environment]::OSVersion.Version.Build -lt 22000) {
|
||||
throw 'GP Connect for ARM64 requires Windows 11.'
|
||||
}
|
||||
$payload = @(Get-ChildItem -LiteralPath $source -Force | Where-Object {
|
||||
($_.PSIsContainer -and $_.Name -eq 'licenses') -or
|
||||
(!$_.PSIsContainer -and ($_.Extension -eq '.dll' -or
|
||||
$_.Name -in @('gpservice.exe', 'gpauth.exe', 'gpgui.exe', 'uninstall.exe', 'build-info.json')))
|
||||
})
|
||||
foreach ($item in $payload) {
|
||||
$items = @($item)
|
||||
if ($item.PSIsContainer) { $items += @(Get-ChildItem -LiteralPath $item.FullName -Force -Recurse) }
|
||||
if ($items | Where-Object { $_.Attributes -band [IO.FileAttributes]::ReparsePoint }) { throw 'The package must not contain file links.' }
|
||||
}
|
||||
$requiredBytes = [long]0
|
||||
foreach ($item in $payload) {
|
||||
if ($item.PSIsContainer) { $requiredBytes += [long](Get-ChildItem -LiteralPath $item.FullName -File -Recurse | Measure-Object -Property Length -Sum).Sum }
|
||||
else { $requiredBytes += $item.Length }
|
||||
}
|
||||
$volume = New-Object IO.DriveInfo([IO.Path]::GetPathRoot($destination))
|
||||
$additionalBytes = $requiredBytes + 16MB
|
||||
if ($ConsumeSource -and [IO.Path]::GetPathRoot($source) -eq $volume.Name) {
|
||||
# The extracted files already occupy this volume; renaming them adds no copy.
|
||||
$additionalBytes = 16MB
|
||||
}
|
||||
if ($volume.AvailableFreeSpace -lt $additionalBytes) { throw 'There is not enough free space to install GP Connect.' }
|
||||
$stage = $destination + '.stage-' + [Guid]::NewGuid().ToString('N')
|
||||
Set-DirectoryAcl $stage $publicAcl
|
||||
foreach ($item in $payload) {
|
||||
if (!$ConsumeSource) {
|
||||
Copy-Item -LiteralPath $item.FullName -Destination $stage -Recurse -Force
|
||||
continue
|
||||
}
|
||||
# NSIS's extracted payload is disposable. Move files individually so temp
|
||||
# and Program Files may be on different volumes without keeping two bundles.
|
||||
$files = @($item)
|
||||
if ($item.PSIsContainer) { $files = @(Get-ChildItem -LiteralPath $item.FullName -File -Recurse) }
|
||||
foreach ($file in $files) {
|
||||
$relative = $file.Name
|
||||
if ($item.PSIsContainer) {
|
||||
# Enumerated paths share the same expanded spelling, including 8.3 temp paths.
|
||||
$child = $file.FullName.Substring($item.FullName.Length).TrimStart('\')
|
||||
$relative = Join-Path $item.Name $child
|
||||
}
|
||||
$target = Join-Path $stage $relative
|
||||
$parent = Split-Path $target -Parent
|
||||
if (!(Test-Path -LiteralPath $parent)) { New-Item -ItemType Directory -Path $parent -Force | Out-Null }
|
||||
Move-Item -LiteralPath $file.FullName -Destination $target
|
||||
}
|
||||
}
|
||||
# Copies inherit the staging directory's protected policy, even when source ACLs differ.
|
||||
foreach ($item in Get-ChildItem -LiteralPath $stage -Force -Recurse) {
|
||||
$acl = Get-Acl -LiteralPath $item.FullName
|
||||
$acl.SetSecurityDescriptorSddlForm($publicAcl)
|
||||
Set-Acl -LiteralPath $item.FullName -AclObject $acl
|
||||
}
|
||||
$signature = Get-AuthenticodeSignature (Join-Path $stage 'wintun.dll')
|
||||
if ($signature.Status -ne 'Valid' -or $signature.SignerCertificate.Subject -notmatch 'WireGuard LLC') {
|
||||
throw 'The package requires the vendor-signed Wintun driver DLL.'
|
||||
}
|
||||
if ((Test-Path -LiteralPath $destination) -and !$existing) { throw 'The service is not registered. Repair the existing installation before updating.' }
|
||||
if ($existing -and !(Test-Path -LiteralPath $destination)) { throw 'The registered installation is missing. Restore its files before updating.' }
|
||||
if (Test-Path $uninstallKey) {
|
||||
$key = Get-Item $uninstallKey
|
||||
$oldMetadata = @{}
|
||||
foreach ($name in $key.GetValueNames()) { $oldMetadata[$name] = @{ Value = $key.GetValue($name); Kind = $key.GetValueKind($name).ToString() } }
|
||||
}
|
||||
if (Test-Path -LiteralPath $shortcutPath) { $oldShortcut = [IO.File]::ReadAllBytes($shortcutPath) }
|
||||
Wait-ForApplications
|
||||
if ($existing) {
|
||||
$serviceStopped = $true
|
||||
Stop-InstalledService
|
||||
Assert-NetworkClean
|
||||
Wait-ForRuntimeRelease
|
||||
}
|
||||
if (Test-Path -LiteralPath $destination) { Move-InstalledDirectoryToBackup; $oldMoved = $true }
|
||||
Move-Item -LiteralPath $stage -Destination $destination
|
||||
$stage = $null
|
||||
$newMoved = $true
|
||||
Set-MachineState
|
||||
if (!$existing) {
|
||||
New-Service -Name $serviceName -DisplayName 'GP Connect' -BinaryPathName ('"' + $serviceBinary + '"') -StartupType Automatic -Description 'Connects GP Connect to your GlobalProtect VPN network.' | Out-Null
|
||||
$createdService = $true
|
||||
} else { Set-Service -Name $serviceName -StartupType Automatic }
|
||||
Invoke-ServiceCommand @('failure', $serviceName, 'reset=', '86400', 'actions=', 'restart/3000/restart/10000/none/0')
|
||||
Set-InstallationMetadata $Version
|
||||
Start-InstalledService
|
||||
$committed = $true
|
||||
if ($oldMoved) { Remove-Item -LiteralPath $backup -Recurse -Force; $oldMoved = $false }
|
||||
Write-Host "Installed GP Connect $Version. Open it from the Start menu."
|
||||
} else {
|
||||
if (!$existing) {
|
||||
if (Test-Path -LiteralPath $destination) { throw 'The service is not registered. Review the installation folder before removing it.' }
|
||||
Write-Host 'GP Connect is not installed.'
|
||||
return
|
||||
}
|
||||
Wait-ForApplications
|
||||
$serviceStopped = $true
|
||||
Stop-InstalledService
|
||||
Assert-NetworkClean
|
||||
Wait-ForRuntimeRelease
|
||||
# Move first: a locked runtime aborts while its registration and files are intact.
|
||||
Move-InstalledDirectoryToBackup
|
||||
$oldMoved = $true
|
||||
Invoke-ServiceCommand @('delete', $serviceName)
|
||||
$committed = $true
|
||||
Remove-Item -LiteralPath $backup -Recurse -Force
|
||||
$oldMoved = $false
|
||||
if (Test-Path -LiteralPath $shortcutPath) { Remove-Item -LiteralPath $shortcutPath -Force }
|
||||
if (Test-Path $uninstallKey) { Remove-Item $uninstallKey -Recurse -Force }
|
||||
if (Test-Path $recoveryKey) { Remove-Item $recoveryKey -Force }
|
||||
Remove-OwnedCallback
|
||||
Write-Host 'Removed GP Connect. User settings and service logs are kept.'
|
||||
}
|
||||
} catch {
|
||||
$failure = $_
|
||||
if (!$committed) {
|
||||
try {
|
||||
if ($newMoved) { Stop-InstalledService; Remove-Item -LiteralPath $destination -Recurse -Force }
|
||||
if ($oldMoved) { Move-Item -LiteralPath $backup -Destination $destination; $oldMoved = $false }
|
||||
if ($createdService) { Invoke-ServiceCommand @('delete', $serviceName) }
|
||||
if ($newMoved) { Restore-InstallationMetadata }
|
||||
if ($existing -and $serviceStopped -and $wasRunning) { Start-InstalledService }
|
||||
} catch {
|
||||
Write-Host "Could not restore GP Connect: $($_.Exception.Message)"
|
||||
Write-Host "Keep any retained files in $backup and run the installer again after restoring the installation."
|
||||
}
|
||||
}
|
||||
Write-Host "Installation failed: $($failure.Exception.Message)"
|
||||
Write-Host "Details: $(Join-Path $state 'installer.log')"
|
||||
throw $failure
|
||||
} finally {
|
||||
if ($stage -and (Test-Path -LiteralPath $stage)) {
|
||||
try { Remove-Item -LiteralPath $stage -Recurse -Force } catch { Write-Warning "Could not remove temporary files: $stage" }
|
||||
}
|
||||
if ($transcript) { Stop-Transcript | Out-Null }
|
||||
if ($owned) { $mutex.ReleaseMutex() }
|
||||
$mutex.Dispose()
|
||||
}
|
||||
Loaded 100 of 119 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user