From fdbe3bcbba6f3cda58ae42ecbdabc4b8bebe4e49 Mon Sep 17 00:00:00 2001 From: Kevin Yue Date: Sat, 14 Nov 2026 23:14:20 +0800 Subject: [PATCH] ci: add Windows package builds and verified update publication --- .github/workflows/build-windows.yaml | 144 +++++++++++++++ .github/workflows/build.yaml | 22 +++ .github/workflows/publish-update-feeds.yaml | 4 + .../publish-windows-update-feed.yaml | 151 ++++++++++++++++ scripts/gh-release.sh | 2 +- scripts/preserve-update-feeds.py | 44 +++++ scripts/tests/test_windows_update_feed.py | 164 ++++++++++++++++++ scripts/validate-update-manifest.py | 4 +- scripts/windows-update-feed.py | 130 ++++++++++++++ 9 files changed, 662 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/build-windows.yaml create mode 100644 .github/workflows/publish-windows-update-feed.yaml create mode 100644 scripts/preserve-update-feeds.py create mode 100644 scripts/tests/test_windows_update_feed.py create mode 100644 scripts/windows-update-feed.py diff --git a/.github/workflows/build-windows.yaml b/.github/workflows/build-windows.yaml new file mode 100644 index 0000000..09d9bf8 --- /dev/null +++ b/.github/workflows/build-windows.yaml @@ -0,0 +1,144 @@ +name: Build Windows package + +on: + 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 + secrets: + GH_PAT: + required: true + WINDOWS_UPDATE_PRIVATE_KEY: + required: true + +permissions: + contents: read + +jobs: + build: + runs-on: windows-2022 + timeout-minutes: 120 + env: + 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: + - 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/rust-toolchain@1.97.0 + - uses: actions/setup-python@v6 + with: + python-version: '3.13' + - uses: msys2/setup-msys2@v2 + id: msys2 + with: + msystem: MINGW64 + update: true + install: >- + base-devel autoconf automake libtool gettext git + mingw-w64-x86_64-gcc mingw-w64-x86_64-pkgconf + mingw-w64-x86_64-gnutls mingw-w64-x86_64-libxml2 + mingw-w64-x86_64-lz4 + - 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 + $nsis = Join-Path $tools 'nsis.zip' + Invoke-WebRequest 'https://downloads.sourceforge.net/project/nsis/NSIS%203/3.12/nsis-3.12.zip' -OutFile $nsis + if ((Get-FileHash $nsis).Hash -ne '56581F90DB321581C5381193D796FFFCF2D24B2F8FED2160A6C6A3BAA67F2C4F') { throw 'NSIS checksum mismatch.' } + Expand-Archive $nsis $tools + Remove-Item $nsis + $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 -Prefix $prefix + & ./source/gp/scripts/test-openconnect-windows.ps1 -MsysRoot $env:MSYS_ROOT -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 ` + -WintunDirectory (Join-Path $env:WINDOWS_BUILD_TOOLS 'wintun') ` + -MakeNsis (Join-Path $env:WINDOWS_BUILD_TOOLS 'nsis-3.12/Bin/makensis.exe') ` + -OutputDirectory "$env:GITHUB_WORKSPACE/artifacts" *> $log + } catch { 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 + 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" + $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 + } + - uses: actions/upload-artifact@v7 + with: + name: artifact-gpgui-windows-x64 + path: | + artifacts/*.exe + artifacts/*.sig + artifacts/*.sha256 + artifacts/*.zip + if-no-files-found: error + retention-days: 14 diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml index 3e97cbe..81a06e2 100644 --- a/.github/workflows/build.yaml +++ b/.github/workflows/build.yaml @@ -42,6 +42,11 @@ on: required: true default: false type: boolean + build_windows: + description: 'Build the Windows x64 NSH installer and development ZIP' + required: true + default: false + type: boolean push: paths-ignore: - LICENSE @@ -465,6 +470,19 @@ 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') }} + uses: ./.github/workflows/build-windows.yaml + with: + 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 +1209,7 @@ jobs: - build-gpgui-glibc - build-gpgui-musl - build-gpgui-nsh + - build-windows - setup-bsd-matrix - build-gpgui-frontend - build-bsd @@ -1201,6 +1220,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 +1240,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}") diff --git a/.github/workflows/publish-update-feeds.yaml b/.github/workflows/publish-update-feeds.yaml index c1157af..baac2de 100644 --- a/.github/workflows/publish-update-feeds.yaml +++ b/.github/workflows/publish-update-feeds.yaml @@ -533,6 +533,10 @@ jobs: CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }} CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }} 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 trap 'status=$?; if [ "$status" -ne 0 ]; then echo "::error::Private operation failed; diagnostics suppressed."; fi' EXIT ( set -euo pipefail diff --git a/.github/workflows/publish-windows-update-feed.yaml b/.github/workflows/publish-windows-update-feed.yaml new file mode 100644 index 0000000..d1bd9fb --- /dev/null +++ b/.github/workflows/publish-windows-update-feed.yaml @@ -0,0 +1,151 @@ +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 the tested installer and detached signature + required: true + type: string + installer_name: + description: Exact Windows x64 installer asset name + 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 }} + INSTALLER_NAME: ${{ inputs.installer_name }} + 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 tested release installer + 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:INSTALLER_NAME -ne "GPConnect_${displayVersion}_windows-x64-setup.exe") { throw 'Installer asset does not match the product version, channel and build.' } + 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 + foreach ($asset in @($env:INSTALLER_NAME, "$env:INSTALLER_NAME.sig", "$env:INSTALLER_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 $env:INSTALLER_NAME + $sum = (Get-Content "$installer.sha256" -Raw).Trim() + if ($sum -notmatch '^([a-fA-F0-9]{64}) (.+)$' -or $Matches[2] -ne $env:INSTALLER_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.' } + . ./gpgui/scripts/windows-updates/Get-WinSparkle.ps1 + $tools = Get-WinSparkleTools (Join-Path $env:RUNNER_TEMP 'signing-tools') + $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.' } + - 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' + $installer = Join-Path (Join-Path $env:RUNNER_TEMP 'windows-update') $env:INSTALLER_NAME + $arguments = @('scripts/windows-update-feed.py', '--installer', $installer, + '--installer-url', "https://github.com/$env:REPOSITORY/releases/download/$env:RELEASE_TAG/$env:INSTALLER_NAME", + '--signature-file', "$installer.sig", '--version', $env:PRODUCT_VERSION, + '--channel', $env:UPDATE_CHANNEL, '--released-at', [DateTime]::UtcNow.ToString('yyyy-MM-dd'), + '--highlights-file', $notes, '--output', $output) + 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 '/', '-')) + Invoke-WebRequest "https://updates.gpgui.com/windows/$relative" -OutFile $downloaded + $actual = [IO.File]::ReadAllBytes($downloaded) + if ([Convert]::ToBase64String($expected) -ne [Convert]::ToBase64String($actual)) { throw "Published feed does not match: $relative" } + } diff --git a/scripts/gh-release.sh b/scripts/gh-release.sh index 728ac6a..5245db4 100755 --- a/scripts/gh-release.sh +++ b/scripts/gh-release.sh @@ -175,7 +175,7 @@ release_snapshot() { # The appcast publisher removes expired macOS snapshots after the new feed # is live. Removing them here would temporarily break the current feed. - if [[ "$asset" == GPConnect_*_arm64.* ]]; then + if [[ "$asset" == GPConnect_*_arm64.* || "$asset" == GPConnect_*_windows-x64-setup.exe* ]]; then continue fi if ! delete_release_asset "$asset"; then diff --git a/scripts/preserve-update-feeds.py b/scripts/preserve-update-feeds.py new file mode 100644 index 0000000..ff6131a --- /dev/null +++ b/scripts/preserve-update-feeds.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python3 +"""Retain other platform/channel feeds before replacing a static Worker deployment.""" +import argparse +import json +from pathlib import Path +from urllib.error import HTTPError +from urllib.parse import urlparse +from urllib.request import urlopen +import xml.etree.ElementTree as ET + +FEEDS = ("appcast.xml", "latest.json", "windows/latest.json", "windows/stable/appcast.xml", "windows/snapshot/appcast.xml") + + +def preserve(base_url: str, directory: Path, exclude: list[str]) -> None: + if urlparse(base_url).scheme != "https": + raise ValueError("feed host must use HTTPS") + for relative in FEEDS: + if relative in exclude: + continue + try: + with urlopen(base_url.rstrip("/") + "/" + relative, timeout=30) as response: + data = response.read(1024 * 1024 + 1) + except HTTPError as error: + if error.code == 404: + continue + raise + if len(data) > 1024 * 1024: + raise ValueError(f"published feed is too large: {relative}") + if relative.endswith(".json"): + json.loads(data) + else: + ET.fromstring(data) + target = directory / relative + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base-url", required=True) + parser.add_argument("--directory", type=Path, required=True) + parser.add_argument("--exclude", action="append", default=[], choices=FEEDS) + args = parser.parse_args() + preserve(args.base_url, args.directory, args.exclude) diff --git a/scripts/tests/test_windows_update_feed.py b/scripts/tests/test_windows_update_feed.py new file mode 100644 index 0000000..525991c --- /dev/null +++ b/scripts/tests/test_windows_update_feed.py @@ -0,0 +1,164 @@ +import argparse +import base64 +import importlib.util +import json +from pathlib import Path +import tempfile +import unittest +from unittest.mock import patch +from urllib.error import HTTPError +import xml.etree.ElementTree as ET + + +def load(name, filename): + spec = importlib.util.spec_from_file_location(name, Path(__file__).parents[1] / filename) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +feed = load("windows_update_feed", "windows-update-feed.py") +preserver = load("preserve_update_feeds", "preserve-update-feeds.py") + + +class WindowsFeedTests(unittest.TestCase): + def args(self, root, channel="stable", version="3.4.0", build=None): + name = feed.installer_name(version, channel, build) + installer = root / name + installer.write_bytes(b"test installer") + signature = root / "installer.sig" + signature.write_text(base64.b64encode(bytes(64)).decode()) + highlights = root / "highlights.txt" + highlights.write_text("Update & improve .\n") + tag = f"v{version}" if channel == "stable" else "snapshot" + return argparse.Namespace(installer=installer, signature_file=signature, + installer_url=f"https://github.com/yuezk/GlobalProtect-openconnect/releases/download/{tag}/{name}", + repository="yuezk/GlobalProtect-openconnect", channel=channel, + version=version, build=build, released_at="2026-11-14", + highlights_file=highlights, input=None, output=root / "windows", allow_localhost=False) + + def test_catalog_and_appcast_keep_the_same_version_and_payload(self): + with tempfile.TemporaryDirectory() as directory: + args = self.args(Path(directory)) + feed.generate(args) + catalog = json.loads((args.output / "latest.json").read_text()) + self.assertEqual(catalog["stable"]["platforms"], ["windows"]) + item = ET.parse(args.output / "stable/appcast.xml").find("channel/item") + self.assertEqual(item.findtext("description"), "Update & improve .") + enclosure = item.find("enclosure") + self.assertEqual(enclosure.get(f"{{{feed.SPARKLE}}}version"), catalog["stable"]["version"]) + self.assertEqual(int(enclosure.get("length")), args.installer.stat().st_size) + self.assertEqual(enclosure.get(f"{{{feed.SPARKLE}}}os"), "windows-x64") + + def test_snapshot_promotion_retains_stable_and_rejects_downgrade(self): + with tempfile.TemporaryDirectory() as directory: + args = self.args(Path(directory)) + feed.generate(args) + args.input = args.output / "latest.json" + args.channel, args.build = "snapshot", "2026.1114.2" + args.installer = args.installer.rename(args.installer.parent / feed.installer_name(args.version, args.channel, args.build)) + args.installer_url = f"https://github.com/{args.repository}/releases/download/snapshot/{args.installer.name}" + feed.generate(args) + catalog = json.loads(args.input.read_text()) + self.assertEqual(catalog["stable"]["version"], "3.4.0") + self.assertEqual(catalog["snapshot"]["build"], "2026.1114.2") + enclosure = ET.parse(args.output / "snapshot/appcast.xml").find("channel/item/enclosure") + self.assertEqual(enclosure.get(f"{{{feed.SPARKLE}}}version"), "3.4.0-snapshot.2026.1114.2") + args.build = "2026.1114.1" + args.installer = args.installer.rename(args.installer.parent / feed.installer_name(args.version, args.channel, args.build)) + args.installer_url = f"https://github.com/{args.repository}/releases/download/snapshot/{args.installer.name}" + with self.assertRaisesRegex(ValueError, "older"): + feed.generate(args) + + def test_snapshot_filename_cannot_advertise_another_build(self): + with tempfile.TemporaryDirectory() as directory: + args = self.args(Path(directory), "snapshot", build="2026.1114.1") + args.build = "2026.1114.2" + with self.assertRaisesRegex(ValueError, "filename does not match"): + feed.generate(args) + + def test_newer_stable_updates_both_native_feeds_and_retains_snapshot_history(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + snapshot = self.args(root, "snapshot", build="2026.1114.2") + feed.generate(snapshot) + stable = self.args(root, version="3.5.0") + stable.input = stable.output / "latest.json" + feed.generate(stable) + catalog = json.loads(stable.input.read_text()) + self.assertEqual(catalog["snapshot"]["baseVersion"], "3.4.0") + self.assertEqual(catalog["snapshot"]["build"], "2026.1114.2") + for channel in ("stable", "snapshot"): + enclosure = ET.parse(stable.output / channel / "appcast.xml").find("channel/item/enclosure") + self.assertEqual(enclosure.get(f"{{{feed.SPARKLE}}}version"), "3.5.0") + self.assertEqual(enclosure.get("url"), stable.installer_url) + + def test_stable_without_snapshot_initializes_both_native_feeds(self): + with tempfile.TemporaryDirectory() as directory: + args = self.args(Path(directory)) + feed.generate(args) + self.assertEqual((args.output / "stable/appcast.xml").read_bytes(), + (args.output / "snapshot/appcast.xml").read_bytes()) + self.assertIsNone(json.loads((args.output / "latest.json").read_text())["snapshot"]) + + def test_stable_does_not_replace_same_or_newer_base_snapshot_feed(self): + for snapshot_version in ("3.4.0", "3.5.0"): + with self.subTest(snapshot_version=snapshot_version), tempfile.TemporaryDirectory() as directory: + root = Path(directory) + snapshot = self.args(root, "snapshot", version=snapshot_version, build="2026.1114.2") + feed.generate(snapshot) + before = (snapshot.output / "snapshot/appcast.xml").read_bytes() + stable = self.args(root) + stable.input = stable.output / "latest.json" + feed.generate(stable) + self.assertEqual((stable.output / "snapshot/appcast.xml").read_bytes(), before) + + def test_snapshot_older_than_stable_is_rejected_without_changing_published_files(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + stable = self.args(root, version="3.5.0") + feed.generate(stable) + published = {relative: (stable.output / relative).read_bytes() + for relative in ("latest.json", "stable/appcast.xml", "snapshot/appcast.xml")} + snapshot = self.args(root, "snapshot", version="3.4.0", build="2026.1114.3") + snapshot.input = stable.output / "latest.json" + with self.assertRaisesRegex(ValueError, "snapshot base version is older"): + feed.generate(snapshot) + for relative, content in published.items(): + self.assertEqual((stable.output / relative).read_bytes(), content) + + def test_private_loopback_download_requires_explicit_opt_in(self): + with tempfile.TemporaryDirectory() as directory: + args = self.args(Path(directory)) + args.installer_url = "http://127.0.0.1:18770/setup.exe" + with self.assertRaisesRegex(ValueError, "matching GitHub"): + feed.generate(args) + args.allow_localhost = True + feed.generate(args) + + def test_missing_or_malformed_signature_is_rejected(self): + with tempfile.TemporaryDirectory() as directory: + args = self.args(Path(directory)) + args.signature_file.write_text("not a signature") + with self.assertRaises(ValueError): + feed.generate(args) + + def test_preservation_keeps_other_feeds_and_does_not_hide_server_errors(self): + class Response: + def __enter__(self): return self + def __exit__(self, *unused): pass + def read(self, length): return b'{"schemaVersion": 1}' + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + with patch.object(preserver, "urlopen", return_value=Response()) as request: + preserver.preserve("https://updates.gpgui.com", root, + ["appcast.xml", "latest.json", "windows/stable/appcast.xml", "windows/snapshot/appcast.xml"]) + self.assertTrue((root / "windows/latest.json").exists()) + self.assertEqual(request.call_count, 1) + with patch.object(preserver, "urlopen", side_effect=HTTPError("url", 500, "failure", {}, None)): + with self.assertRaises(HTTPError): + preserver.preserve("https://updates.gpgui.com", root, []) + + +if __name__ == "__main__": + unittest.main() diff --git a/scripts/validate-update-manifest.py b/scripts/validate-update-manifest.py index d47ec63..be3990a 100644 --- a/scripts/validate-update-manifest.py +++ b/scripts/validate-update-manifest.py @@ -10,7 +10,7 @@ import unicodedata from pathlib import Path from urllib.parse import urlparse -ALLOWED_PLATFORMS = {"linux", "freebsd", "openbsd"} +ALLOWED_PLATFORMS = {"linux", "freebsd", "openbsd", "windows"} SEMVER = re.compile(r"^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$") BUILD = re.compile(r"^(0|[1-9][0-9]*)(?:\.(0|[1-9][0-9]*)){0,2}$") EXPECTED_TOP_LEVEL_KEYS = {"schemaVersion", "stable", "snapshot"} @@ -192,7 +192,7 @@ def main() -> None: generate_parser.add_argument("--channel", choices=("stable", "snapshot"), required=True) generate_parser.add_argument("--version", required=True) generate_parser.add_argument("--platform", action="append", choices=sorted(ALLOWED_PLATFORMS), - help="Published Unix target; repeat for multiple targets (default: all)") + help="Published target; repeat for multiple targets (default: Unix targets)") generate_parser.add_argument("--build") generate_parser.add_argument("--released-at", required=True) generate_parser.add_argument("--highlights-file", required=True, type=Path) diff --git a/scripts/windows-update-feed.py b/scripts/windows-update-feed.py new file mode 100644 index 0000000..9e3a2ab --- /dev/null +++ b/scripts/windows-update-feed.py @@ -0,0 +1,130 @@ +#!/usr/bin/env python3 +"""Build the Windows catalog and WinSparkle appcast from one verified installer.""" +from __future__ import annotations + +import argparse +import base64 +import hashlib +import importlib.util +import json +from pathlib import Path +from urllib.parse import urlparse +import xml.etree.ElementTree as ET + +SPARKLE = "http://www.andymatuschak.org/xml-namespaces/sparkle" +ET.register_namespace("sparkle", SPARKLE) +spec = importlib.util.spec_from_file_location("update_manifest", Path(__file__).with_name("validate-update-manifest.py")) +manifest = importlib.util.module_from_spec(spec) +spec.loader.exec_module(manifest) + + +def release_version(version: str, channel: str, build: str | None) -> str: + if channel == "snapshot": + return f"{version}-snapshot.{build}" + return version + + +def installer_name(version: str, channel: str, build: str | None) -> str: + return f"GPConnect_{release_version(version, channel, build)}_windows-x64-setup.exe" + + +def generate(args: argparse.Namespace) -> None: + manifest.version_tuple(args.version) + if args.channel == "snapshot": + if args.build is None: + raise ValueError("snapshot releases require --build") + manifest.build_tuple(args.build) + elif args.build is not None: + raise ValueError("stable releases must not specify --build") + expected_name = installer_name(args.version, args.channel, args.build) + if not args.allow_localhost and args.installer.name != expected_name: + raise ValueError("installer filename does not match the version, channel and build") + parsed = urlparse(args.installer_url) + tag = f"v{args.version}" if args.channel == "stable" else "snapshot" + expected = f"https://github.com/{args.repository}/releases/download/{tag}/" + local = args.allow_localhost and parsed.scheme == "http" and parsed.hostname in {"localhost", "127.0.0.1", "::1"} + if not local and not args.installer_url.startswith(expected): + raise ValueError("installer URL must identify the matching GitHub release asset") + if parsed.query or parsed.fragment or not parsed.path.endswith(".exe"): + raise ValueError("installer URL must name an EXE without query or fragment") + if not local and parsed.path.rsplit("/", 1)[-1] != expected_name: + raise ValueError("installer download filename does not match the version, channel and build") + signature = args.signature_file.read_text(encoding="ascii").strip() + if len(base64.b64decode(signature, validate=True)) != 64: + raise ValueError("EdDSA signature must contain 64 bytes") + length = args.installer.stat().st_size + if length == 0: + raise ValueError("installer is empty") + if args.channel == "snapshot" and args.input is not None: + previous = manifest.validate_manifest(json.loads(args.input.read_text(encoding="utf-8")), args.repository) + stable = previous["stable"] + if stable is not None and manifest.version_tuple(args.version) < manifest.version_tuple(stable["version"]): + raise ValueError("snapshot base version is older than the published stable release") + output = args.output + output.mkdir(parents=True, exist_ok=True) + catalog = output / "latest.json" + manifest.generate(argparse.Namespace( + repository=args.repository, channel=args.channel, version=args.version, + platform=["windows"], build=args.build, released_at=args.released_at, + highlights_file=args.highlights_file, input=args.input, output=catalog, + )) + data = json.loads(catalog.read_text(encoding="utf-8")) + if any(release and release["platforms"] != ["windows"] for release in [data["stable"], data["snapshot"]]): + raise ValueError("Windows catalog may contain only the Windows target") + release = data[args.channel] + display_version = release_version(args.version, args.channel, args.build) + rss = ET.Element("rss", {"version": "2.0"}) + channel = ET.SubElement(rss, "channel") + ET.SubElement(channel, "title").text = "GP Connect for Windows" + item = ET.SubElement(channel, "item") + ET.SubElement(item, "title").text = f"GP Connect {display_version}" + ET.SubElement(item, "description").text = "\n".join(release["highlights"]) + ET.SubElement(item, f"{{{SPARKLE}}}minimumSystemVersion").text = "10.0.19041" + ET.SubElement(item, "enclosure", { + "url": args.installer_url, "length": str(length), "type": "application/octet-stream", + f"{{{SPARKLE}}}version": display_version, + f"{{{SPARKLE}}}shortVersionString": display_version, + f"{{{SPARKLE}}}os": "windows-x64", f"{{{SPARKLE}}}edSignature": signature, + }) + ET.indent(rss) + channels = [args.channel] + snapshot = data["snapshot"] + if args.channel == "stable" and ( + snapshot is None or manifest.version_tuple(args.version) > manifest.version_tuple(snapshot["baseVersion"]) + ): + # Core offers a newer stable release to snapshot installations too. + # Keep the snapshot catalog history, but route its native install feed + # to the same newer stable candidate until a new snapshot is promoted. + channels.append("snapshot") + for target_channel in channels: + channel_directory = output / target_channel + channel_directory.mkdir(exist_ok=True) + ET.ElementTree(rss).write(channel_directory / "appcast.xml", encoding="utf-8", xml_declaration=True) + with args.installer.open("rb") as installer: + digest = hashlib.file_digest(installer, "sha256").hexdigest() + (output / (args.installer.name + ".sha256")).write_text(f"{digest} {args.installer.name}\n", encoding="ascii") + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--installer", type=Path, required=True) + parser.add_argument("--installer-url", required=True) + parser.add_argument("--signature-file", type=Path, required=True) + parser.add_argument("--repository", default="yuezk/GlobalProtect-openconnect") + parser.add_argument("--channel", choices=("stable", "snapshot"), required=True) + parser.add_argument("--version", required=True) + parser.add_argument("--build") + parser.add_argument("--released-at", required=True) + parser.add_argument("--highlights-file", type=Path, required=True) + parser.add_argument("--input", type=Path) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--allow-localhost", action="store_true", help="Permit an isolated loopback test download") + args = parser.parse_args() + try: + generate(args) + except (OSError, ValueError) as error: + parser.error(str(error)) + + +if __name__ == "__main__": + main()