Compare commits

...
Author SHA1 Message Date
shadowdaoandClaude Opus 5.5 614e89bef4 fix(ssm-plugin): lock down the Windows work root; re-hash the output in place
Secret Scan / scan (push) Successful in 14s
Build App (Preview) / compute-version (pull_request) Successful in 14s
Secret Scan / scan (pull_request) Successful in 7s
Build App (Preview) / test (pull_request) Successful in 9m25s
Build App (Preview) / create-release (pull_request) Successful in 1s
Build App (Preview) / build-macos (pull_request) Successful in 6m40s
Build App (Preview) / build-linux (pull_request) Successful in 17m3s
Build App (Preview) / build-windows (pull_request) Successful in 13m53s
Build App (Preview) / prune-previews (pull_request) Successful in 2s
The short %SystemDrive%\ssm-<8hex> root inherited the drive root's ACL,
where Authenticated Users can write, so another local user could swap the
source, toolchain or output between verification and use. Right after
creating it, icacls removes inheritance and grants full control only to
SYSTEM, Administrators and the current user's SID; failure aborts. It is
mandatory on Windows and skipped only off Windows (the pwsh test path).
The binary is hashed again at its final location.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 08:21:55 -08:00
shadowdaoandClaude Opus 5.5 b62f472d79 fix(ssm-plugin): review fixes for the source build and signing checks
Secret Scan / scan (push) Successful in 11s
Build App (Preview) / compute-version (pull_request) Successful in 11s
Secret Scan / scan (pull_request) Successful in 12s
Build App (Preview) / create-release (pull_request) Successful in 1s
Build App (Preview) / build-macos (pull_request) Successful in 6m42s
Build App (Preview) / test (pull_request) Successful in 15m11s
Build App (Preview) / build-linux (pull_request) Successful in 13m45s
Build App (Preview) / build-windows (pull_request) Successful in 13m59s
Build App (Preview) / prune-previews (pull_request) Successful in 2s
- build-ssm-plugin.{sh,ps1}: skip the vendored SDK's Java codegen/ and
  test snapshot/ trees when extracting (codegen paths reach 258 chars,
  past MAX_PATH on Windows); the .ps1 works under a short
  %SystemDrive%\ssm-<8hex> root and falls back to rd /s /q on cleanup.
  Pinned output hashes unchanged (rebuilt every target).
- build-ssm-plugin.sh: the header no longer claims a git commit-id check.
- windows-verify-signatures.ps1: compare signer Subject + Issuer, not the
  thumbprint (Artifact Signing certificates rotate); require
  THIRD_PARTY_NOTICES in the MSI.
- windows-sign.ps1: allowlist exactly
  src-tauri\binaries\session-manager-plugin-x86_64-pc-windows-msvc.exe.
- macOS jobs: check the .app carries the two-slice plugin and
  Contents/Resources/THIRD_PARTY_NOTICES.
- CLAUDE.md: a local release build must re-run the build script.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 08:20:09 -08:00
shadowdaoandClaude Opus 5.5 5b23dc1aec build: build session-manager-plugin from source, not AWS's binaries
Build App (Preview) / compute-version (pull_request) Successful in 5s
Secret Scan / scan (push) Successful in 8s
Secret Scan / scan (pull_request) Successful in 7s
Build App (Preview) / create-release (pull_request) Successful in 2s
Build App (Preview) / build-macos (pull_request) Successful in 6m42s
Build App (Preview) / build-linux (pull_request) Successful in 12m41s
Build App (Preview) / build-windows (pull_request) Successful in 13m57s
Build App (Preview) / test (pull_request) Successful in 23m29s
Build App (Preview) / prune-previews (pull_request) Successful in 3s
AWS ships its prebuilt plugin as "AWS Content" under the AWS Customer
Agreement; the source is Apache-2.0. Replace the binary fetch with
scripts/build-ssm-plugin.sh (any triple, cross-compiles; universal via
lipo) and build-ssm-plugin.ps1 (Windows runner):

- source: tag 1.2.896.0 at commit 6430675a, GitHub archive SHA-256
  checked before extraction;
- Go 1.26.11 from go.dev, published SHA-256 checked before use;
- the repo's own build (GOPATH mode, vendored deps, -s -w,
  sessionmanagerplugin-main) with VERSION stamped to the tag, plus
  -trimpath, no VCS stamp, empty build id, CGO off;
- output must equal a pinned SHA-256 per target (reproducible builds).

Each platform job builds its own targets. Windows: the exe is now ours
and unsigned, so windows-sign.ps1 allowlists it and
windows-verify-signatures.ps1 requires it signed by the installer's own
certificate in the MSI and NSIS. THIRD_PARTY_NOTICES now carries the
source's LICENSE/NOTICE/THIRD-PARTY, the commit, every linked vendored
module's licence and Go's. AWS's GPG key and the AWS-signature checks
are gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 08:12:11 -08:00
shadowdaoandClaude Opus 5.5 381158cca0 docs: the bundled AWS session-manager-plugin
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:44:30 -08:00
shadowdaoandClaude Opus 5.5 cb28d1da39 ci: fetch the SSM plugin before every build; check it ships
Both build workflows fetch the pinned plugin before tauri build on Linux,
macOS (universal: both slices plus the lipo'd file) and Windows. The test
job needs no fetch: debug builds get build.rs's placeholder.

finalize-appimage.sh asserts usr/bin/session-manager-plugin is a running
ELF and THIRD_PARTY_NOTICES is in the image.

Windows: the plugin ships under AWS's Authenticode signature and is not
re-signed (Tauri skips a sidecar signtool verify accepts).
windows-sign.ps1 refuses it if it is ever presented rather than letting the
allowlist skip it unsigned; windows-verify-signatures.ps1 requires it in
the MSI, valid, timestamped and signed by Amazon Web Services, Inc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:44:30 -08:00
shadowdaoandClaude Opus 5.5 39f502dcdf feat(ssm): bundle session-manager-plugin as a sidecar and prefer it
bundle.externalBin ships the plugin beside the app binary (usr/bin in the
AppImage, Contents/MacOS, the Windows install dir) and THIRD_PARTY_NOTICES as
a resource. find_plugin() now resolves TRIPLEC_SSM_PLUGIN, then the bundled
sidecar next to current_exe(), then PATH and AWS's install locations, then
the install hint; the order is unit-tested against temp dirs.

tauri-build fails any build whose externalBin file is missing, so build.rs
writes a marked placeholder in debug builds (cargo test/check, tauri dev)
and refuses a missing file or a placeholder in release builds.
find_plugin() skips the placeholder.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:43:41 -08:00
shadowdaoandClaude Opus 5.5 05ac6b3e8c build: fetch a pinned, verified AWS session-manager-plugin
scripts/fetch-ssm-plugin.sh (Linux/macOS, incl. universal via lipo) and
scripts/fetch-ssm-plugin.ps1 (Windows) download plugin 1.2.896.0 from AWS's
S3 path into app/src-tauri/binaries/session-manager-plugin-<triple>[.exe],
checking a pinned SHA-256 of each artifact before extraction, AWS's GPG
signature on the Linux .deb (key committed, fingerprint pinned) or AWS's
Authenticode signature on Windows, and a pinned SHA-256 of the binary.

THIRD_PARTY_NOTICES reproduces the plugin's LICENSE (Apache-2.0), NOTICE
and AWS's THIRD-PARTY statement. The binaries directory is never committed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 06:43:41 -08:00
jknapp fe7c474070 Merge pull request 'AWS host phase 7: ECS on EC2 (per-user capacity, Docker access, VPN)' (#84) from feat/aws-ec2 into main
Secret Scan / scan (push) Successful in 7s
Build Container / build-container (push) Successful in 1m9s
2026-11-17 14:28:45 +00:00
16 changed files with 2132 additions and 37 deletions

No files matched your search

+42 -1
View File
@@ -334,7 +334,9 @@ jobs:
run: npx vitest run run: npx vitest run
# `--locked`: test against the committed Cargo.lock, never a re-resolved # `--locked`: test against the committed Cargo.lock, never a re-resolved
# one, for the same reason the frontend uses `npm ci`. # one, for the same reason the frontend uses `npm ci`. No plugin fetch
# here: a debug build gets a placeholder for the session-manager-plugin
# sidecar from build.rs, so tests never build Go or download anything.
- name: Backend tests (cargo test) - name: Backend tests (cargo test)
working-directory: ./app/src-tauri working-directory: ./app/src-tauri
run: | run: |
@@ -468,6 +470,14 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH" export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin, bundled as a sidecar (bundle.externalBin)
# so AWS workspaces work without the user installing it. Built here from
# AWS's Apache-2.0 source (pinned commit + archive SHA-256) with a pinned,
# hash-checked Go; the output must match a pinned SHA-256 (reproducible
# build). A release build refuses to start without it (build.rs).
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh x86_64-unknown-linux-gnu
- name: Build Tauri app - name: Build Tauri app
working-directory: ./app working-directory: ./app
env: env:
@@ -597,6 +607,15 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH" export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.sh): both thin slices (tauri-build checks
# each arch it compiles) and the lipo'd universal one the bundler copies
# into Contents/MacOS. Each must match its pinned SHA-256. Signed exactly
# like the app: Go ad-hoc signs the arm64 slice, and with APPLE_* signing
# configured Tauri would sign the sidecar with the app's identity.
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh universal-apple-darwin
- name: Build Tauri app (universal) - name: Build Tauri app (universal)
working-directory: ./app working-directory: ./app
env: env:
@@ -606,6 +625,21 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH" export PATH="$HOME/.cargo/bin:$PATH"
npx tauri build --target universal-apple-darwin npx tauri build --target universal-apple-darwin
# The sidecar and its notices must be in the bundle Tauri made: the
# plugin in Contents/MacOS with both slices, THIRD_PARTY_NOTICES in
# Contents/Resources (bundle.resources).
- name: Check the bundled Session Manager plugin
run: |
app_dir="$(ls -d app/src-tauri/target/universal-apple-darwin/release/bundle/macos/*.app | head -n1)"
[ -n "$app_dir" ] || { echo "no .app bundle"; exit 1; }
plugin="$app_dir/Contents/MacOS/session-manager-plugin"
[ -x "$plugin" ] || { echo "missing $plugin"; exit 1; }
archs="$(lipo -archs "$plugin")"
case " $archs " in *" x86_64 "*) ;; *) echo "plugin lacks x86_64 ($archs)"; exit 1 ;; esac
case " $archs " in *" arm64 "*) ;; *) echo "plugin lacks arm64 ($archs)"; exit 1 ;; esac
"$plugin" --version
[ -f "$app_dir/Contents/Resources/THIRD_PARTY_NOTICES" ] || { echo "missing Contents/Resources/THIRD_PARTY_NOTICES"; exit 1; }
- name: Collect artifacts - name: Collect artifacts
run: | run: |
mkdir -p artifacts mkdir -p artifacts
@@ -729,6 +763,13 @@ jobs:
set "PATH=%USERPROFILE%\.cargo\bin;C:\Program Files\nodejs;%PATH%" set "PATH=%USERPROFILE%\.cargo\bin;C:\Program Files\nodejs;%PATH%"
npm run build npm run build
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.ps1); must match its pinned SHA-256. It
# comes out unsigned, so it ships unsigned in previews, like the
# app (releases sign it: see build-app.yml).
- name: Build the AWS Session Manager plugin
run: powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File scripts\build-ssm-plugin.ps1
- name: Build Tauri app - name: Build Tauri app
working-directory: ./app working-directory: ./app
# Previews are not code-signed: signing is metered, previews are built # Previews are not code-signed: signing is metered, previews are built
+39
View File
@@ -227,6 +227,14 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH" export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin, bundled as a sidecar (bundle.externalBin)
# so AWS workspaces work without the user installing it. Built here from
# AWS's Apache-2.0 source (pinned commit + archive SHA-256) with a pinned,
# hash-checked Go; the output must match a pinned SHA-256 (reproducible
# build). A release build refuses to start without it (build.rs).
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh x86_64-unknown-linux-gnu
- name: Build Tauri app - name: Build Tauri app
working-directory: ./app working-directory: ./app
run: | run: |
@@ -417,12 +425,36 @@ jobs:
export PATH="$HOME/.cargo/bin:$PATH" export PATH="$HOME/.cargo/bin:$PATH"
npx tauri --version || npm install @tauri-apps/cli npx tauri --version || npm install @tauri-apps/cli
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.sh): both thin slices (tauri-build checks
# each arch it compiles) and the lipo'd universal one the bundler copies
# into Contents/MacOS. Each must match its pinned SHA-256. Signed exactly
# like the app: Go ad-hoc signs the arm64 slice, and with APPLE_* signing
# configured Tauri would sign the sidecar with the app's identity.
- name: Build the AWS Session Manager plugin
run: bash scripts/build-ssm-plugin.sh universal-apple-darwin
- name: Build Tauri app (universal) - name: Build Tauri app (universal)
working-directory: ./app working-directory: ./app
run: | run: |
export PATH="$HOME/.cargo/bin:$PATH" export PATH="$HOME/.cargo/bin:$PATH"
npx tauri build --target universal-apple-darwin npx tauri build --target universal-apple-darwin
# The sidecar and its notices must be in the bundle Tauri made: the
# plugin in Contents/MacOS with both slices, THIRD_PARTY_NOTICES in
# Contents/Resources (bundle.resources).
- name: Check the bundled Session Manager plugin
run: |
app_dir="$(ls -d app/src-tauri/target/universal-apple-darwin/release/bundle/macos/*.app | head -n1)"
[ -n "$app_dir" ] || { echo "no .app bundle"; exit 1; }
plugin="$app_dir/Contents/MacOS/session-manager-plugin"
[ -x "$plugin" ] || { echo "missing $plugin"; exit 1; }
archs="$(lipo -archs "$plugin")"
case " $archs " in *" x86_64 "*) ;; *) echo "plugin lacks x86_64 ($archs)"; exit 1 ;; esac
case " $archs " in *" arm64 "*) ;; *) echo "plugin lacks arm64 ($archs)"; exit 1 ;; esac
"$plugin" --version
[ -f "$app_dir/Contents/Resources/THIRD_PARTY_NOTICES" ] || { echo "missing Contents/Resources/THIRD_PARTY_NOTICES"; exit 1; }
- name: Collect artifacts - name: Collect artifacts
run: | run: |
mkdir -p artifacts mkdir -p artifacts
@@ -656,6 +688,13 @@ jobs:
set "PATH=%USERPROFILE%\.cargo\bin;C:\Program Files\nodejs;%PATH%" set "PATH=%USERPROFILE%\.cargo\bin;C:\Program Files\nodejs;%PATH%"
npm run build npm run build
# The AWS Session Manager plugin sidecar (bundle.externalBin), built from
# source (see build-ssm-plugin.ps1); must match its pinned SHA-256. It
# comes out unsigned, so Tauri hands it to the sign command and
# "Verify signatures" requires our signature on it in both installers.
- name: Build the AWS Session Manager plugin
run: powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File scripts\build-ssm-plugin.ps1
# Releases are signed with Azure Artifact Signing (scripts/windows-*.ps1). # Releases are signed with Azure Artifact Signing (scripts/windows-*.ps1).
# The setup fetches the signing client and a job-local .NET runtime, and # The setup fetches the signing client and a job-local .NET runtime, and
# writes the Tauri config holding the sign command, which "Build Tauri # writes the Tauri config holding the sign command, which "Build Tauri
+4
View File
@@ -27,3 +27,7 @@ screenshot_for_fix/
*.tfstate *.tfstate
*.tfstate.* *.tfstate.*
.terraform.tfstate.lock.info .terraform.tfstate.lock.info
# The bundled AWS session-manager-plugin sidecar (scripts/build-ssm-plugin.*, built from source) and the
# debug-build placeholder build.rs writes there. Never committed.
app/src-tauri/binaries/
+74 -5
View File
@@ -14,7 +14,8 @@ All frontend/tauri commands run from the `app/` directory:
cd app cd app
npm ci # Install dependencies (required first time) npm ci # Install dependencies (required first time)
npx tauri dev # Launch app in dev mode with hot reload (Vite on port 1420) npx tauri dev # Launch app in dev mode with hot reload (Vite on port 1420)
npx tauri build # Production build (outputs to src-tauri/target/release/bundle/) npx tauri build # Production build (outputs to src-tauri/target/release/bundle/);
# run ../scripts/build-ssm-plugin.sh first (bundled AWS plugin, see Packaging)
npm run build # Frontend-only build (tsc + vite) npm run build # Frontend-only build (tsc + vite)
npm run test # Run Vitest once npm run test # Run Vitest once
npm run test:watch # Run Vitest in watch mode npm run test:watch # Run Vitest in watch mode
@@ -1225,10 +1226,77 @@ verbatim copy yields a launcher entry that starts nothing. It keeps `StartupWMCl
the bundle sets it, which is what lets the shell match the window to the entry. Extraction uses the bundle sets it, which is what lets the shell match the window to the entry. Extraction uses
`--appimage-extract`, which needs no FUSE, so the script works before `fuse2` is installed. `--appimage-extract`, which needs no FUSE, so the script works before `fuse2` is installed.
### The bundled AWS Session Manager plugin
AWS workspaces connect through AWS's `session-manager-plugin` (`host/ssm.rs`), and the app
**bundles it as a Tauri sidecar** (`bundle.externalBin: binaries/session-manager-plugin`) so users
need not install it. Tauri copies it beside the app binary with the `-<target-triple>` suffix
stripped — `usr/bin/session-manager-plugin` in the AppImage, `Contents/MacOS/` on macOS, the
install directory on Windows (`session-manager-plugin.exe`), and `target/<profile>/` under
`tauri dev`. `find_plugin()` resolves `TRIPLEC_SSM_PLUGIN` → **that sidecar (beside
`current_exe()`)** → `PATH` → AWS's install locations → the install hint; the order is
unit-tested (`host/ssm/tests.rs`, `plugin_resolution`).
- **We build it from source; we never ship AWS's binaries.** AWS distributes its prebuilt plugin
as "AWS Content" under the AWS Customer Agreement; the source (github.com/aws/session-manager-plugin)
is Apache-2.0. `scripts/build-ssm-plugin.sh <triple>…` (Linux/macOS; any triple, it
cross-compiles) and `scripts/build-ssm-plugin.ps1` (the Windows runner, which has no bash) take
the tag's **commit** as GitHub's archive (pinned SHA-256, checked before extraction; the
vendored SDK's Java `codegen/` and test `snapshot/` trees are not extracted — they reach 258
characters, past Windows' MAX_PATH, so the `.ps1` also works under a short `C:\ssm-<8hex>` root)
and a
**pinned Go** from go.dev (go.dev's published SHA-256), and run the repo's own build — GOPATH
mode over its vendored deps, `-ldflags "-s -w"`, `sessionmanagerplugin-main` — with `VERSION`
stamped to the tag (the repo's file says `1.3.0.0`; AWS's pipeline stamps the real one, so
`--version` would otherwise lie), plus `-trimpath`, no VCS stamp, empty build id, `CGO_ENABLED=0`
and a scrubbed Go environment. **The output must equal a pinned SHA-256 per target**: Go builds
are reproducible across hosts, so every runner must produce the exact bytes recorded in the
scripts (verified locally: Linux-hosted builds of every target, repeated in fresh directories,
and the `.ps1` flow, are identical). A mismatch fails the build and means the source, toolchain
or flags changed — never "update the hash" without knowing which.
- **Each platform job builds its own targets** before `tauri build` (Linux: `x86_64-unknown-linux-gnu`;
macOS: `universal-apple-darwin`, i.e. both thin slices — tauri-build checks the arch it compiles —
plus the `lipo`'d universal file the bundler wants, whose slices must thin back out byte-identical
to the pins; Windows: the `.ps1`). Not one Linux job feeding the others: workflow artifacts do
not work on this Gitea (see `build-app-preview.yml`'s header), and with reproducible output and
pinned hashes nothing is gained by building once.
- **Bumping** the plugin or Go: new pins in **both** scripts, rebuild every target, record the new
output hashes, and update `app/src-tauri/THIRD_PARTY_NOTICES` (the scripts refuse to run unless
its `Version:`/`Commit:` lines match) including its dependency licences.
- **Debug builds get a placeholder; release builds refuse one.** tauri-build fails *any* build
whose externalBin file is missing, `cargo test` included. `build.rs` (`ensure_ssm_sidecar`)
writes a marked placeholder (`src/sidecar_placeholder.rs`) for a missing file when
`PROFILE=debug`, so `cargo test`/`cargo check`/`tauri dev` and CI's `test` job need neither Go
nor the network, and `find_plugin()` skips it (falling back to an installed plugin). With
`PROFILE=release` a missing file **or** a placeholder stops the build, so a local `cargo build
--release` needs the build script first. **build.rs rejects only a missing file or the
placeholder, not a stale or wrong binary**: re-run `scripts/build-ssm-plugin.sh` before every
local release build (it is a no-op when the file already matches the pin, and rebuilds it
otherwise — e.g. after a pin bump, or after a Windows release build signed it in place). `finalize-appimage.sh` asserts the shipped
`usr/bin/session-manager-plugin` is an ELF that runs `--version`.
- **Windows: our build is unsigned, so the release signs it with our certificate.** Tauri runs
`signtool verify /pa` on each sidecar and hands the unsigned one to the sign command, in place
under `app\src-tauri\binaries` before any bundle (both MSI and NSIS pack that file);
`windows-sign.ps1`'s allowlist includes it (one more metered signature per release: 6).
`windows-verify-signatures.ps1` requires exactly one `session-manager-plugin.exe` in the MSI and
the file NSIS packed to be validly signed, timestamped, **by the same signing identity
(subject + issuer) as the installer** — not the thumbprint: Artifact Signing certificates are
short-lived and rotate — and the signing log to show it. The MSI must also carry
`THIRD_PARTY_NOTICES`; on macOS a workflow step checks the `.app` holds the two-slice plugin in
`Contents/MacOS` and the notices in `Contents/Resources`. Previews ship it unsigned, like the app.
- **macOS: signed exactly like the app.** The app is not code-signed (no `APPLE_*`/`signingIdentity`
in the workflows); Go's linker ad-hoc signs the arm64 slice (needed to run on Apple Silicon). If
signing is ever configured, Tauri signs externalBin with the app's identity, inside-out.
- **Licence:** `app/src-tauri/THIRD_PARTY_NOTICES` (bundled as a resource; `usr/lib/Triple-C/` in
the AppImage, asserted by `finalize-appimage.sh`) carries the plugin's Apache-2.0 LICENSE and
NOTICE, the commit we build, the repo's own `THIRD-PARTY` file verbatim, the licence of every
vendored module linked in (`go list -deps` for linux/darwin/windows) and Go's own. Note that the
repo's `THIRD-PARTY` file opens with the same "AWS Content" sentence as the binary packages.
### Windows code signing ### Windows code signing
Windows **releases** (`build-app.yml`) are signed with **Azure Artifact Signing**: the app binary, Windows **releases** (`build-app.yml`) are signed with **Azure Artifact Signing**: the app binary,
the MSI, the NSIS installer and its uninstaller. Three scripts do it, and "Verify signatures" the bundled `session-manager-plugin`, the MSI, the NSIS installer and its uninstaller. Three scripts do it, and "Verify signatures"
fails the job if any of them is unsigned or untimestamped, so an unsigned installer cannot ship fails the job if any of them is unsigned or untimestamped, so an unsigned installer cannot ship
quietly. **PR previews are deliberately not signed**, and `build-app-preview.yml` must not quietly. **PR previews are deliberately not signed**, and `build-app-preview.yml` must not
reference the signing secrets. Two reasons: signing is metered (about 1000 signatures a month, reference the signing secrets. Two reasons: signing is metered (about 1000 signatures a month,
@@ -1246,12 +1314,13 @@ without releasing (see Releases above).
- `scripts/windows-sign.ps1` is the sign command: `signtool sign /dlib` with SHA-256 and the - `scripts/windows-sign.ps1` is the sign command: `signtool sign /dlib` with SHA-256 and the
Microsoft timestamp server, retried. Credentials never reach a command line — the dlib reads Microsoft timestamp server, retried. Credentials never reach a command line — the dlib reads
`AZURE_TENANT_ID` / `AZURE_CLIENT_ID` / `AZURE_CLIENT_SECRET` from the environment. `AZURE_TENANT_ID` / `AZURE_CLIENT_ID` / `AZURE_CLIENT_SECRET` from the environment.
**It signs only an allowlist of what ships**: 5 signatures per release (the app binary twice, **It signs only an allowlist of what ships**: 6 signatures per release (the app binary twice,
because Tauri re-patches it between the MSI and NSIS bundles; the MSI; the NSIS installer; because Tauri re-patches it between the MSI and NSIS bundles; the MSI; the NSIS installer;
and its uninstaller). Tauri also presents build-time tools, the WiX extension DLLs and NSIS its uninstaller; and the `session-manager-plugin` sidecar we build from source). Tauri also presents build-time tools, the WiX extension DLLs and NSIS
plugins, and signing those would more than double the metered count for no user-visible plugins, and signing those would more than double the metered count for no user-visible
benefit. If the app ever ships resource DLLs or sidecars, extend the benefit. If the app ever ships resource DLLs or sidecars, extend the
allowlist, or they will go out unsigned. Tauri reports a failed sign command only as allowlist, or they will go out unsigned (as `session-manager-plugin`'s entry does; see the
section above). Tauri reports a failed sign command only as
"failed to run powershell", so the script keeps a transcript (`.code-signing/sign-output.log`, "failed to run powershell", so the script keeps a transcript (`.code-signing/sign-output.log`,
`signtool /debug` included), and the job prints it on failure. `signtool /debug` included), and the job prints it on failure.
- `scripts/windows-verify-signatures.ps1` checks `signtool verify /pa` plus a timestamp on the - `scripts/windows-verify-signatures.ps1` checks `signtool verify /pa` plus a timestamp on the
File diff suppressed because it is too large. Load diff
+50
View File
@@ -14,6 +14,8 @@
#[path = "src/command_census.rs"] #[path = "src/command_census.rs"]
mod command_census; mod command_census;
#[path = "src/sidecar_placeholder.rs"]
mod sidecar_placeholder;
use std::path::Path; use std::path::Path;
@@ -79,6 +81,7 @@ fn main() {
} }
prune_permissions(&commands); prune_permissions(&commands);
ensure_ssm_sidecar();
// `AppManifest::commands` takes `&'static [&'static str]` and the struct is `Copy`, so // `AppManifest::commands` takes `&'static [&'static str]` and the struct is `Copy`, so
// there is no owned form; leaking is fine in a process that exits right after. // there is no owned form; leaking is fine in a process that exits right after.
@@ -206,3 +209,50 @@ fn check_tauri_config() {
fail("capabilities declared outside capabilities/", &problems, LAYOUT_HINT); fail("capabilities declared outside capabilities/", &problems, LAYOUT_HINT);
} }
} }
/// `bundle.externalBin` names `binaries/session-manager-plugin`, and tauri-build stops on a
/// missing `binaries/session-manager-plugin-<target-triple>[.exe]` for every build, tests
/// included. The real one is built from AWS's source by `scripts/build-ssm-plugin.sh` (`.ps1` on
/// Windows), which CI runs before `tauri build`.
///
/// - **Release profile:** the real plugin is required. A missing file or a placeholder stops
/// the build here, so a placeholder can never ship.
/// - **Debug profile** (`cargo test`, `cargo check`, `tauri dev`): a missing file is replaced
/// by a placeholder (`src/sidecar_placeholder.rs`) so no test run needs Go or the network. The app's
/// `find_plugin` skips a placeholder and falls back to an installed plugin.
fn ensure_ssm_sidecar() {
let target = std::env::var("TARGET").expect("cargo sets TARGET");
let ext = if target.contains("windows") { ".exe" } else { "" };
let path = Path::new("binaries").join(format!("session-manager-plugin-{target}{ext}"));
println!("cargo:rerun-if-changed={}", path.display());
let release = std::env::var("PROFILE").as_deref() == Ok("release");
let head = std::fs::read(&path).ok().map(|b| sidecar_placeholder::is_placeholder(&b));
let build = if target.contains("windows") {
"scripts\\build-ssm-plugin.ps1"
} else {
"scripts/build-ssm-plugin.sh"
};
match (head, release) {
(Some(false), _) => {}
(state, true) => fail(
"the AWS Session Manager plugin sidecar is missing",
&[format!(
"{} is {} (release builds bundle the real plugin)",
path.display(),
if state.is_some() { "a debug-build placeholder" } else { "missing" }
)],
&format!("Run {build} {target} from the repository root first."),
),
(None, false) => {
std::fs::create_dir_all("binaries").expect("create src-tauri/binaries");
std::fs::write(&path, sidecar_placeholder::contents())
.unwrap_or_else(|e| panic!("cannot write {}: {e}", path.display()));
println!(
"cargo:warning=no {} - wrote a placeholder (debug only; AWS workspaces use an \
installed plugin). Run {build} to build the real one.",
path.display()
);
}
(Some(true), false) => {}
}
}
+82 -26
View File
@@ -198,27 +198,48 @@ fn sdk_error(e: &(dyn std::error::Error + 'static)) -> String {
// ── The plugin ─────────────────────────────────────────────────────────────── // ── The plugin ───────────────────────────────────────────────────────────────
/// Find `session-manager-plugin`: `TRIPLEC_SSM_PLUGIN` if set, then `PATH`, /// The plugin's file name on this platform: what the bundle holds (Tauri strips the
/// then where AWS's installers put it (the GUI app on macOS does not get the /// `-<target-triple>` suffix of `bundle.externalBin` when it copies the sidecar in) and what
/// shell's `PATH`, so the install locations are not optional). /// AWS's installers put on `PATH`.
const PLUGIN_FILE: &str =
if cfg!(windows) { "session-manager-plugin.exe" } else { "session-manager-plugin" };
const PLUGIN_INSTALL_HINT: &str = "The AWS Session Manager plugin (session-manager-plugin) is \
not installed. It is what connects to a workspace on AWS; install it from \
https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html";
/// Find `session-manager-plugin`, in this order:
///
/// 1. `TRIPLEC_SSM_PLUGIN`, if set (an error if it names no file — an explicit choice is never
/// silently replaced by another plugin);
/// 2. **the copy bundled with the app** (`bundle.externalBin`), beside the app's own
/// executable: `usr/bin` in the AppImage, `Contents/MacOS` in the macOS bundle, the install
/// directory on Windows (and `target/<profile>` under `tauri dev`, where tauri-build copies
/// it). A debug build's placeholder (`sidecar_placeholder`) is skipped;
/// 3. `PATH`;
/// 4. where AWS's installers put it (the GUI app on macOS does not get the shell's `PATH`, so
/// the install locations are not optional).
///
/// 3 and 4 remain for dev builds without a fetched sidecar.
pub fn find_plugin() -> Result<PathBuf, String> { pub fn find_plugin() -> Result<PathBuf, String> {
if let Some(p) = std::env::var_os("TRIPLEC_SSM_PLUGIN").filter(|p| !p.is_empty()) { let exe_dir = std::env::current_exe()
let p = PathBuf::from(p); .ok()
return if p.is_file() { .and_then(|exe| exe.parent().map(Path::to_path_buf));
Ok(p) resolve_plugin(&PluginSearch {
} else { override_path: std::env::var_os("TRIPLEC_SSM_PLUGIN"),
Err(format!("TRIPLEC_SSM_PLUGIN names {}, which is not a file", p.display())) exe_dir,
}; path_var: std::env::var_os("PATH"),
} install_dirs: plugin_install_dirs(),
let name = if cfg!(windows) { "session-manager-plugin.exe" } else { "session-manager-plugin" }; })
let on_path = std::env::var_os("PATH") }
.map(|paths| std::env::split_paths(&paths).map(|d| d.join(name)).collect::<Vec<_>>())
.unwrap_or_default(); /// Where AWS's installers put the plugin, in the order they are tried.
let installed: Vec<PathBuf> = if cfg!(windows) { fn plugin_install_dirs() -> Vec<PathBuf> {
if cfg!(windows) {
["ProgramFiles", "ProgramFiles(x86)"] ["ProgramFiles", "ProgramFiles(x86)"]
.iter() .iter()
.filter_map(|v| std::env::var_os(v)) .filter_map(|v| std::env::var_os(v))
.map(|d| PathBuf::from(d).join(r"Amazon\SessionManagerPlugin\bin").join(name)) .map(|d| PathBuf::from(d).join(r"Amazon\SessionManagerPlugin\bin"))
.collect() .collect()
} else { } else {
[ [
@@ -228,19 +249,54 @@ pub fn find_plugin() -> Result<PathBuf, String> {
"/usr/bin", "/usr/bin",
] ]
.iter() .iter()
.map(|d| Path::new(d).join(name)) .map(PathBuf::from)
.collect() .collect()
}; }
}
/// Everything [`find_plugin`] reads from the process, so the order is testable.
struct PluginSearch {
override_path: Option<std::ffi::OsString>,
exe_dir: Option<PathBuf>,
path_var: Option<std::ffi::OsString>,
install_dirs: Vec<PathBuf>,
}
fn resolve_plugin(search: &PluginSearch) -> Result<PathBuf, String> {
if let Some(p) = search.override_path.as_ref().filter(|p| !p.is_empty()) {
let p = PathBuf::from(p);
return if p.is_file() {
Ok(p)
} else {
Err(format!("TRIPLEC_SSM_PLUGIN names {}, which is not a file", p.display()))
};
}
if let Some(bundled) = search.exe_dir.as_ref().map(|d| d.join(PLUGIN_FILE)) {
if bundled.is_file() && !is_sidecar_placeholder(&bundled) {
return Ok(bundled);
}
}
let on_path = search
.path_var
.as_ref()
.map(|paths| std::env::split_paths(paths).map(|d| d.join(PLUGIN_FILE)).collect::<Vec<_>>())
.unwrap_or_default();
on_path on_path
.into_iter() .into_iter()
.chain(installed) .chain(search.install_dirs.iter().map(|d| d.join(PLUGIN_FILE)))
.find(|p| p.is_file()) .find(|p| p.is_file())
.ok_or_else(|| { .ok_or_else(|| PLUGIN_INSTALL_HINT.to_string())
"The AWS Session Manager plugin (session-manager-plugin) is not installed. It is \ }
what connects to a workspace on AWS; install it from \
https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html" /// Whether `path` is the stand-in a debug build bundles when no real plugin was fetched.
.to_string() /// Unreadable counts as "not a placeholder": the spawn then reports the real error.
}) fn is_sidecar_placeholder(path: &Path) -> bool {
use std::io::Read;
let mut head = [0u8; crate::sidecar_placeholder::MARKER.len()];
std::fs::File::open(path)
.and_then(|mut f| f.read_exact(&mut head))
.map(|()| crate::sidecar_placeholder::is_placeholder(&head))
.unwrap_or(false)
} }
/// A running plugin process with a listener on the local port. /// A running plugin process with a listener on the local port.
+132
View File
@@ -400,3 +400,135 @@ async fn the_keepalive_asks_for_health_without_a_token() {
assert!(req.starts_with("GET /v1/health HTTP/1.1\r\n"), "{req}"); assert!(req.starts_with("GET /v1/health HTTP/1.1\r\n"), "{req}");
assert!(!req.to_ascii_lowercase().contains("authorization"), "{req}"); assert!(!req.to_ascii_lowercase().contains("authorization"), "{req}");
} }
// ── Finding the plugin ───────────────────────────────────────────────────────
mod plugin_resolution {
use super::super::{resolve_plugin, PluginSearch, PLUGIN_FILE, PLUGIN_INSTALL_HINT};
use std::path::{Path, PathBuf};
/// A directory holding a fake plugin (contents are never run).
fn dir_with_plugin(root: &Path, name: &str) -> PathBuf {
let d = root.join(name);
std::fs::create_dir_all(&d).unwrap();
std::fs::write(d.join(PLUGIN_FILE), b"\x7fELF fake plugin").unwrap();
d
}
fn search(
override_path: Option<&Path>,
exe_dir: Option<&Path>,
path: &[&Path],
install: &[&Path],
) -> PluginSearch {
PluginSearch {
override_path: override_path.map(|p| p.as_os_str().to_owned()),
exe_dir: exe_dir.map(Path::to_path_buf),
path_var: Some(std::env::join_paths(path).unwrap()),
install_dirs: install.iter().map(|p| p.to_path_buf()).collect(),
}
}
#[test]
fn the_override_wins_over_everything() {
let t = tempfile::tempdir().unwrap();
let chosen = t.path().join("my-plugin");
std::fs::write(&chosen, b"x").unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let on_path = dir_with_plugin(t.path(), "path");
let s = search(Some(&chosen), Some(&bundled), &[&on_path], &[]);
assert_eq!(resolve_plugin(&s).unwrap(), chosen);
}
#[test]
fn an_override_naming_no_file_is_an_error_not_a_fallback() {
let t = tempfile::tempdir().unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let s = search(Some(&t.path().join("missing")), Some(&bundled), &[], &[]);
let e = resolve_plugin(&s).unwrap_err();
assert!(e.contains("TRIPLEC_SSM_PLUGIN names"), "{e}");
}
#[test]
fn an_empty_override_is_ignored() {
let t = tempfile::tempdir().unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let mut s = search(None, Some(&bundled), &[], &[]);
s.override_path = Some(std::ffi::OsString::new());
assert_eq!(resolve_plugin(&s).unwrap(), bundled.join(PLUGIN_FILE));
}
#[test]
fn the_bundled_sidecar_wins_over_path_and_installs() {
let t = tempfile::tempdir().unwrap();
let bundled = dir_with_plugin(t.path(), "app");
let on_path = dir_with_plugin(t.path(), "path");
let installed = dir_with_plugin(t.path(), "installed");
let s = search(None, Some(&bundled), &[&on_path], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), bundled.join(PLUGIN_FILE));
}
#[test]
fn without_a_sidecar_path_comes_before_the_install_locations() {
let t = tempfile::tempdir().unwrap();
let empty_app = t.path().join("app");
std::fs::create_dir_all(&empty_app).unwrap();
let first = t.path().join("path-first-empty");
std::fs::create_dir_all(&first).unwrap();
let on_path = dir_with_plugin(t.path(), "path");
let installed = dir_with_plugin(t.path(), "installed");
let s = search(None, Some(&empty_app), &[&first, &on_path], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), on_path.join(PLUGIN_FILE));
let s = search(None, Some(&empty_app), &[&first], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), installed.join(PLUGIN_FILE));
}
#[test]
fn a_debug_placeholder_beside_the_exe_is_skipped() {
let t = tempfile::tempdir().unwrap();
let app = t.path().join("app");
std::fs::create_dir_all(&app).unwrap();
std::fs::write(app.join(PLUGIN_FILE), crate::sidecar_placeholder::contents()).unwrap();
let on_path = dir_with_plugin(t.path(), "path");
let s = search(None, Some(&app), &[&on_path], &[]);
assert_eq!(resolve_plugin(&s).unwrap(), on_path.join(PLUGIN_FILE));
// And with nothing else installed, the install hint, not the placeholder.
let s = search(None, Some(&app), &[], &[]);
assert_eq!(resolve_plugin(&s).unwrap_err(), PLUGIN_INSTALL_HINT);
}
#[test]
fn a_directory_named_like_the_plugin_is_not_a_plugin() {
let t = tempfile::tempdir().unwrap();
let app = t.path().join("app");
std::fs::create_dir_all(app.join(PLUGIN_FILE)).unwrap();
let installed = dir_with_plugin(t.path(), "installed");
let s = search(None, Some(&app), &[], &[&installed]);
assert_eq!(resolve_plugin(&s).unwrap(), installed.join(PLUGIN_FILE));
}
#[test]
fn nothing_anywhere_is_the_install_hint() {
let t = tempfile::tempdir().unwrap();
let s = search(None, None, &[t.path()], &[t.path()]);
let e = resolve_plugin(&s).unwrap_err();
assert!(e.contains("is not installed") && e.contains("docs.aws.amazon.com"), "{e}");
}
#[test]
fn the_bundled_name_is_what_tauri_gives_the_sidecar() {
// tauri-build/-bundler strip "-<target-triple>" from bundle.externalBin's
// "binaries/session-manager-plugin"; the .exe stays on Windows.
let conf: serde_json::Value =
serde_json::from_str(include_str!("../../../tauri.conf.json")).unwrap();
let bins = conf["bundle"]["externalBin"].as_array().expect("bundle.externalBin");
let stems: Vec<&str> = bins
.iter()
.map(|b| b.as_str().unwrap().rsplit('/').next().unwrap())
.collect();
let expected = PLUGIN_FILE.trim_end_matches(".exe");
assert!(stems.contains(&expected), "{stems:?} has no {expected}");
}
}
+1
View File
@@ -15,6 +15,7 @@ mod logging;
mod marketplace; mod marketplace;
mod models; mod models;
mod project_lock; mod project_lock;
mod sidecar_placeholder;
mod storage; mod storage;
pub mod url_open; pub mod url_open;
pub mod web_terminal; pub mod web_terminal;
+32
View File
@@ -0,0 +1,32 @@
//! The stand-in `build.rs` writes for the bundled `session-manager-plugin` sidecar in a
//! **debug** build that has no real one, and how the app recognises it.
//!
//! `bundle.externalBin` makes tauri-build fail outright when the per-target file is missing,
//! for `cargo test`, `cargo check` and `tauri dev` as much as for a release. The real binary
//! is built from AWS's pinned source by `scripts/build-ssm-plugin.sh` (`.ps1` on Windows), with
//! a downloaded Go toolchain; requiring that for every test run would put a Go build and the
//! network on the path of every `cargo test`. So debug builds get this placeholder instead, a
//! release build refuses it (`build.rs`), and `host::ssm::find_plugin` skips it and falls back to
//! an installed plugin.
//!
//! Shared by `build.rs` (through `#[path]`) and the app, so the two cannot disagree.
/// The first bytes of a placeholder. Not an executable format on any platform.
pub const MARKER: &[u8] = b"TRIPLE-C SSM PLUGIN PLACEHOLDER";
/// The whole placeholder file.
#[allow(dead_code)] // build.rs only
pub fn contents() -> Vec<u8> {
let mut v = MARKER.to_vec();
v.extend_from_slice(
b"\nNot the AWS Session Manager plugin. Debug builds get this when \
app/src-tauri/binaries has no real one; run scripts/build-ssm-plugin.sh \
(scripts/build-ssm-plugin.ps1 on Windows) to build the real plugin.\n",
);
v
}
/// Whether `bytes` (the start of a file) is a placeholder.
pub fn is_placeholder(bytes: &[u8]) -> bool {
bytes.starts_with(MARKER)
}
+6
View File
@@ -36,6 +36,12 @@
"icons/icon.icns", "icons/icon.icns",
"icons/icon.png" "icons/icon.png"
], ],
"externalBin": [
"binaries/session-manager-plugin"
],
"resources": {
"THIRD_PARTY_NOTICES": "THIRD_PARTY_NOTICES"
},
"linux": { "linux": {
"appimage": { "appimage": {
"bundleMediaFramework": true "bundleMediaFramework": true
+154
View File
@@ -0,0 +1,154 @@
# build-ssm-plugin.ps1 - build AWS's session-manager-plugin FROM SOURCE for
# Windows and put it where Tauri's bundle.externalBin expects it:
#
# app\src-tauri\binaries\session-manager-plugin-x86_64-pc-windows-msvc.exe
#
# The Windows runner's half of scripts/build-ssm-plugin.sh - read that header
# for the why. The same pins and the same build, so it must produce the same
# bytes (Go builds are reproducible across hosts); keep the two in step.
#
# 1. Source: AWS's tag 1.2.896.0 by COMMIT, as GitHub's archive of that
# commit, SHA-256 checked before extraction (and its top directory must
# name the commit).
# 2. Toolchain: Go, pinned, SHA-256 as published by go.dev, checked before use.
# 3. AWS's own build (GOPATH mode over the vendored deps, -ldflags "-s -w"),
# version stamped to the tag, made reproducible (-trimpath, no VCS stamp,
# empty build id, CGO off, GOAMD64=v1, nothing inherited).
# 4. The output must equal the pinned SHA-256.
#
# The result is UNSIGNED: in a release build Tauri presents it to the sign
# command (windows-sign.ps1 signs it with our certificate), and
# windows-verify-signatures.ps1 requires our signature on it in both installers.
#
# Needs tar.exe (bsdtar, in every Windows 10+). Idempotent.
$ErrorActionPreference = 'Stop'
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
Add-Type -AssemblyName System.IO.Compression.FileSystem
$PluginVersion = '1.2.896.0'
$PluginCommit = '6430675a44032a551be1937fb27a2d3fdfeb27f7'
$SourceUrl = "https://codeload.github.com/aws/session-manager-plugin/tar.gz/$PluginCommit"
$SourceSha = '7C95BE411AD5F43D14D01460500BFD5A5AA0E28BA94815F8B049AF33A2C381B0'
$GoVersion = '1.26.11'
$GoSha = '71AE086F0137E665F855A811CC119152B6A783E0BBC1B906E709F46D80141EB0' # go1.26.11.windows-amd64.zip, go.dev
$BinarySha = '6D428E5FD77E76D9713F0C42B8EC39F2DE1031E5F3C567FEB73C7FE11B14B226'
$Triple = 'x86_64-pc-windows-msvc'
$repoRoot = Split-Path -Parent $PSScriptRoot
$destDir = Join-Path $repoRoot 'app\src-tauri\binaries'
$dest = Join-Path $destDir "session-manager-plugin-$Triple.exe"
$notices = Join-Path $repoRoot 'app\src-tauri\THIRD_PARTY_NOTICES'
function Get-Sha256([string]$Path) { (Get-FileHash -LiteralPath $Path -Algorithm SHA256).Hash.ToUpperInvariant() }
if (-not ((Select-String -LiteralPath $notices -SimpleMatch "Version: $PluginVersion" -Quiet) -and
(Select-String -LiteralPath $notices -SimpleMatch "Commit: $PluginCommit" -Quiet))) {
throw "$notices does not name plugin $PluginVersion at $PluginCommit - update it with the bump"
}
if ((Test-Path -LiteralPath $dest) -and ((Get-Sha256 $dest) -eq $BinarySha)) {
Write-Host "session-manager-plugin-$Triple.exe: already the pinned $PluginVersion build"
exit 0
}
# A short work root, not %TEMP% (on the runner that is deep under
# systemprofile): the longest extracted path is ~200 characters, and MAX_PATH
# is 260 for Windows PowerShell 5.1, tar.exe and the Go build alike.
$work = Join-Path "$env:SystemDrive\" ('ssm-' + [guid]::NewGuid().ToString('N').Substring(0, 8))
New-Item -ItemType Directory -Path $work | Out-Null
# A directory at the drive root inherits C:\'s ACL, where Authenticated Users
# may create and modify files - another local user could swap the source, the
# toolchain or the output between our checks and their use. So before anything
# lands in it: no inheritance, full control for SYSTEM, Administrators and this
# process's own user only. Mandatory on Windows; skipped only where there is no
# Windows ACL (the Linux pwsh test path).
if ($env:OS -eq 'Windows_NT') {
$me = [Security.Principal.WindowsIdentity]::GetCurrent().User.Value
& icacls.exe $work /inheritance:r /grant:r '*S-1-5-18:(OI)(CI)F' '*S-1-5-32-544:(OI)(CI)F' "*${me}:(OI)(CI)F" | Out-Null
if ($LASTEXITCODE -ne 0) {
Remove-Item -LiteralPath $work -Recurse -Force -ErrorAction SilentlyContinue
throw "icacls could not restrict $work ($LASTEXITCODE)"
}
}
$ProgressPreference = 'SilentlyContinue'
try {
$goZip = Join-Path $work 'go.zip'
Write-Host "Downloading Go $GoVersion (windows-amd64)"
Invoke-WebRequest -Uri "https://go.dev/dl/go$GoVersion.windows-amd64.zip" -OutFile $goZip -UseBasicParsing
$actual = Get-Sha256 $goZip
if ($actual -ne $GoSha) { throw "SHA-256 mismatch for the Go toolchain: got $actual, pinned $GoSha" }
[IO.Compression.ZipFile]::ExtractToDirectory($goZip, (Join-Path $work 'toolchain'))
$go = Join-Path $work 'toolchain\go\bin\go.exe'
$srcTgz = Join-Path $work 'source.tar.gz'
Write-Host "Downloading session-manager-plugin $PluginVersion source ($PluginCommit)"
Invoke-WebRequest -Uri $SourceUrl -OutFile $srcTgz -UseBasicParsing
$actual = Get-Sha256 $srcTgz
if ($actual -ne $SourceSha) { throw "SHA-256 mismatch for the plugin source: got $actual, pinned $SourceSha" }
$srcDir = Join-Path $work 'src'
New-Item -ItemType Directory -Path $srcDir | Out-Null
# Only what the build reads, as build-ssm-plugin.sh does: the vendored SDK's
# Java codegen/ tree reaches 258 characters inside the archive, past
# MAX_PATH, and its snapshot/ files are test data.
& tar.exe --exclude='*/codegen/*' --exclude='*/snapshot/*' -xzf $srcTgz -C $srcDir
if ($LASTEXITCODE -ne 0) { throw "tar.exe could not extract the source ($LASTEXITCODE)" }
$goSpace = Join-Path $srcDir "session-manager-plugin-$PluginCommit"
if (-not (Test-Path -LiteralPath (Join-Path $goSpace 'src\sessionmanagerplugin-main'))) {
throw "the source archive is not the pinned commit's tree"
}
# A clean, fully specified Go environment for everything below.
foreach ($v in 'GOFLAGS', 'GOROOT', 'GOBIN', 'GOEXPERIMENT', 'GOTMPDIR') { Remove-Item "env:$v" -ErrorAction SilentlyContinue }
$gopath = Join-Path $work 'gopath'
$env:GOENV = 'off'; $env:GOTOOLCHAIN = 'local'; $env:GO111MODULE = 'off'; $env:GOPROXY = 'off'; $env:GOWORK = 'off'
$env:GOPATH = "$gopath;$(Join-Path $goSpace 'vendor')"
$env:GOCACHE = Join-Path $work 'cache'; $env:GOMODCACHE = Join-Path $work 'modcache'
$env:CGO_ENABLED = '0'; $env:GOAMD64 = 'v1'; $env:GOARM64 = 'v8.0'
# makefile pre-build: stamp the version with AWS's own generator.
[IO.File]::WriteAllText((Join-Path $goSpace 'VERSION'), $PluginVersion)
# version-gen runs on this host, so no GOOS/GOARCH yet.
Remove-Item env:GOOS, env:GOARCH -ErrorAction SilentlyContinue
Push-Location $goSpace
try { & $go run ./src/version/versiongenerator/version-gen.go | Out-Null } finally { Pop-Location }
if ($LASTEXITCODE -ne 0) { throw "version-gen failed ($LASTEXITCODE)" }
if (-not (Select-String -LiteralPath (Join-Path $goSpace 'src\version\version.go') -SimpleMatch "const Version = `"$PluginVersion`"" -Quiet)) {
throw 'the version stamp did not take'
}
# makefile copy-src: GOPATH mode, from a copy at the import path.
$pkgRoot = Join-Path $gopath 'src\github.com\aws\session-manager-plugin'
New-Item -ItemType Directory -Force -Path $pkgRoot | Out-Null
Copy-Item -Recurse -LiteralPath (Join-Path $goSpace 'src') -Destination $pkgRoot
$out = Join-Path $work 'session-manager-plugin.exe'
Write-Host "Building session-manager-plugin $PluginVersion for windows/amd64"
$env:GOOS = 'windows'; $env:GOARCH = 'amd64'
Push-Location $pkgRoot
try {
& $go build -trimpath -buildvcs=false -ldflags '-s -w -buildid=' -o $out `
github.com/aws/session-manager-plugin/src/sessionmanagerplugin-main
} finally { Pop-Location }
if ($LASTEXITCODE -ne 0) { throw "go build failed ($LASTEXITCODE)" }
$actual = Get-Sha256 $out
if ($actual -ne $BinarySha) {
throw "the windows/amd64 build is not the pinned binary: got $actual, pinned $BinarySha (source, toolchain or build flags changed)"
}
New-Item -ItemType Directory -Force -Path $destDir | Out-Null
Move-Item -LiteralPath $out -Destination $dest -Force
# And what landed is still what was checked.
$actual = Get-Sha256 $dest
if ($actual -ne $BinarySha) {
Remove-Item -LiteralPath $dest -Force -ErrorAction SilentlyContinue
throw "$dest changed after it was verified: got $actual, pinned $BinarySha"
}
Write-Host "session-manager-plugin-$Triple.exe: session-manager-plugin $PluginVersion (unsigned; signed by the release build)"
} finally {
Remove-Item -LiteralPath $work -Recurse -Force -ErrorAction SilentlyContinue
# PS 5.1's Remove-Item can give up on read-only files and deep trees;
# rd /s /q is the fallback.
if (Test-Path -LiteralPath $work) { cmd /c rd /s /q "`"$work`"" | Out-Null }
if (Test-Path -LiteralPath $work) { Write-Warning "could not remove $work" }
}
+233
View File
@@ -0,0 +1,233 @@
#!/usr/bin/env bash
#
# build-ssm-plugin.sh [target-triple ...] - build AWS's session-manager-plugin
# FROM SOURCE and put it where Tauri's `bundle.externalBin` expects it:
#
# app/src-tauri/binaries/session-manager-plugin-<target-triple>[.exe]
#
# The app runs the plugin to connect to workspaces on AWS; bundling it means
# users do not have to install it. We build it ourselves from AWS's Apache-2.0
# source (github.com/aws/session-manager-plugin) rather than redistributing
# AWS's prebuilt binaries, which AWS ships as "AWS Content" under the AWS
# Customer Agreement.
#
# With no argument the host's triple is used (`rustc -vV`). Every target is a
# pure-Go cross-compile (CGO_ENABLED=0), so any host can build any of them; CI
# builds each platform's own targets in its own job. scripts/build-ssm-plugin.ps1
# is the same build for the Windows runner, which has no bash.
#
# Supported triples:
# x86_64-unknown-linux-gnu linux/amd64
# aarch64-unknown-linux-gnu linux/arm64
# x86_64-apple-darwin darwin/amd64
# aarch64-apple-darwin darwin/arm64
# universal-apple-darwin both darwin slices plus the two thin files,
# joined with lipo (`tauri build --target
# universal-apple-darwin` compiles each arch and
# tauri-build wants each arch's sidecar; the
# bundler then wants the universal one)
# x86_64-pc-windows-msvc windows/amd64 (for local cross-builds; CI uses
# the .ps1)
#
# Trust and reproducibility - the build fails on any miss:
# 1. The source is AWS's tag 1.2.896.0, pinned by COMMIT, downloaded as
# GitHub's archive of that commit and checked against a pinned SHA-256
# BEFORE extraction (the SHA-256 is the check; the archive's top
# directory, which names the commit, must also be there). Only what the
# build reads is extracted: the vendored SDK's Java `codegen/` tree and its
# test `snapshot/` files are skipped, which also keeps every path under
# Windows' MAX_PATH (the .ps1 extracts the same way, so both build the
# same tree).
# 2. The Go toolchain is a pinned release from go.dev, checked against the
# SHA-256 go.dev publishes (https://go.dev/dl/?mode=json), before use.
# 3. The build is AWS's own (its makefile: GOPATH mode over the vendored
# dependencies, `-ldflags "-s -w"`, package sessionmanagerplugin-main),
# with VERSION set to the tag so `--version` prints 1.2.896.0 (AWS's
# release pipeline stamps it; the repo's VERSION file says 1.3.0.0), plus
# what makes it reproducible: -trimpath, no VCS stamping, an empty build
# id, CGO off, explicit GOAMD64/GOARM64, no inherited GOFLAGS.
# 4. The output must equal a PINNED SHA-256 per target. Go builds are
# bit-for-bit reproducible across hosts, so every CI runner must produce
# exactly the binary recorded here; a mismatch means the source, the
# toolchain or the build changed.
#
# To bump the plugin or Go: change the pins in this script and in
# build-ssm-plugin.ps1, rebuild every target, record the new output hashes
# (both scripts), and update the version/commit lines in
# app/src-tauri/THIRD_PARTY_NOTICES (checked below) and its dependency licences.
#
# Idempotent: a destination that already holds the pinned binary is left alone.
set -euo pipefail
PLUGIN_VERSION="1.2.896.0"
PLUGIN_COMMIT="6430675a44032a551be1937fb27a2d3fdfeb27f7"
SOURCE_URL="https://codeload.github.com/aws/session-manager-plugin/tar.gz/${PLUGIN_COMMIT}"
SOURCE_SHA256="7c95be411ad5f43d14d01460500bfd5a5aa0e28ba94815f8b049af33a2c381b0"
GO_VERSION="1.26.11"
go_pin() { # <goos-goarch of the build host> -> SHA-256 published by go.dev
case "$1" in
linux-amd64) echo 9849f4e04ee35303714e34fbc3ac8ab44ea3e448a95aa182f91e3b9b79c710ec ;;
linux-arm64) echo 6c2f29b458b5add0835f18b776f69c8881a6d88428f1484a6da55755e620757e ;;
darwin-amd64) echo 394baae971332f2bc783d6e2004ae57101479bd3b06ed8209a3fe3570d4ce498 ;;
darwin-arm64) echo e3a42e67a7a8acf450ebada2b074c7ca863000ca514907b7185b45e8f5cdff57 ;;
*) return 1 ;;
esac
}
# target triple -> GOOS GOARCH SHA-256 of the binary we build
target_pin() {
case "$1" in
x86_64-unknown-linux-gnu) echo "linux amd64 414dafe49a90428cb4271a28ea964ad9242a26cb08a38d9679d808470c3b6b62" ;;
aarch64-unknown-linux-gnu) echo "linux arm64 79f00cd41536611e2906a9ea703175ab4f06f9b81107a0357b2304c8bfac61dd" ;;
x86_64-apple-darwin) echo "darwin amd64 fc61cd7e30bef3524a3681dc6b1a0f472506d9c98bccf62a67865067c9f2f059" ;;
aarch64-apple-darwin) echo "darwin arm64 9f3857f85cbcdc88e3ca686f84ac2a794e19e1778ad47ac3294c39e700de08f8" ;;
x86_64-pc-windows-msvc) echo "windows amd64 6d428e5fd77e76d9713f0c42b8ec39f2de1031e5f3c567feb73c7fe11b14b226" ;;
*) return 1 ;;
esac
}
repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
dest_dir="$repo_root/app/src-tauri/binaries"
notices="$repo_root/app/src-tauri/THIRD_PARTY_NOTICES"
die() { echo "build-ssm-plugin: $*" >&2; exit 1; }
sha256() {
if command -v sha256sum >/dev/null 2>&1; then
sha256sum "$1" | cut -d' ' -f1
else
shasum -a 256 "$1" | cut -d' ' -f1
fi
}
# The notices name the version and commit they describe; a bump updates both.
grep -qF "Version: ${PLUGIN_VERSION}" "$notices" && grep -qF "Commit: ${PLUGIN_COMMIT}" "$notices" \
|| die "$notices does not name plugin ${PLUGIN_VERSION} at ${PLUGIN_COMMIT} - update it with the bump"
work="$(mktemp -d)"
trap 'rm -rf "$work"' EXIT
prepared=false
download() { # <url> <out>
curl -fsSL --proto '=https' --tlsv1.2 --retry 3 --retry-delay 5 -o "$2" "$1" \
|| die "download failed: $1"
}
# Toolchain and source, once per run, both verified before they are unpacked.
prepare() {
[ "$prepared" = true ] && return 0
local host_os host_arch go_sha go_tgz
case "$(uname -s)" in Linux) host_os=linux ;; Darwin) host_os=darwin ;; *) die "unsupported build host $(uname -s)" ;; esac
case "$(uname -m)" in x86_64|amd64) host_arch=amd64 ;; arm64|aarch64) host_arch=arm64 ;; *) die "unsupported build host arch $(uname -m)" ;; esac
go_sha="$(go_pin "$host_os-$host_arch")" || die "no pinned Go for $host_os-$host_arch"
go_tgz="$work/go.tar.gz"
echo "Downloading Go ${GO_VERSION} (${host_os}-${host_arch})"
download "https://go.dev/dl/go${GO_VERSION}.${host_os}-${host_arch}.tar.gz" "$go_tgz"
[ "$(sha256 "$go_tgz")" = "$go_sha" ] \
|| die "SHA-256 mismatch for the Go toolchain: got $(sha256 "$go_tgz"), pinned $go_sha"
mkdir -p "$work/toolchain"
tar -xzf "$go_tgz" -C "$work/toolchain"
GO="$work/toolchain/go/bin/go"
local src_tgz="$work/source.tar.gz"
echo "Downloading session-manager-plugin ${PLUGIN_VERSION} source (${PLUGIN_COMMIT})"
download "$SOURCE_URL" "$src_tgz"
[ "$(sha256 "$src_tgz")" = "$SOURCE_SHA256" ] \
|| die "SHA-256 mismatch for the plugin source: got $(sha256 "$src_tgz"), pinned $SOURCE_SHA256"
mkdir -p "$work/src"
tar --exclude='*/codegen/*' --exclude='*/snapshot/*' -xzf "$src_tgz" -C "$work/src"
GO_SPACE="$work/src/session-manager-plugin-${PLUGIN_COMMIT}"
[ -d "$GO_SPACE/src/sessionmanagerplugin-main" ] || die "the source archive is not the pinned commit's tree"
# makefile `pre-build`: stamp the version with AWS's own generator.
printf '%s' "$PLUGIN_VERSION" >"$GO_SPACE/VERSION"
( cd "$GO_SPACE" && go_env "$(go_host_os)" "$(go_host_arch)" "$GO" run ./src/version/versiongenerator/version-gen.go >/dev/null )
grep -qF "const Version = \"${PLUGIN_VERSION}\"" "$GO_SPACE/src/version/version.go" \
|| die "the version stamp did not take"
# makefile `copy-src`: the code builds in GOPATH mode, from a copy at its
# import path, with the vendored dependencies as a second GOPATH entry.
GOPATH_DIR="$work/gopath"
mkdir -p "$GOPATH_DIR/src/github.com/aws/session-manager-plugin"
cp -R "$GO_SPACE/src" "$GOPATH_DIR/src/github.com/aws/session-manager-plugin/"
prepared=true
}
go_host_os() { "$GO" env GOHOSTOS; }
go_host_arch() { "$GO" env GOHOSTARCH; }
# Run with a clean, fully specified Go environment (nothing inherited).
go_env() { # <goos> <goarch> <cmd...>
local goos="$1" goarch="$2"; shift 2
env -u GOFLAGS -u GOROOT -u GOBIN -u GOEXPERIMENT \
GOENV=off GOTOOLCHAIN=local GO111MODULE=off GOPROXY=off GOWORK=off \
GOPATH="${GOPATH_DIR:-$work/gopath}:${GO_SPACE}/vendor" \
GOCACHE="$work/cache" GOMODCACHE="$work/modcache" GOTMPDIR= \
CGO_ENABLED=0 GOOS="$goos" GOARCH="$goarch" GOAMD64=v1 GOARM64=v8.0 \
"$@"
}
build_thin() { # <triple> <out>
local triple="$1" out="$2" pin goos goarch want
pin="$(target_pin "$triple")" || die "unsupported target $triple"
read -r goos goarch want <<<"$pin"
if [ -f "$out" ] && [ "$(sha256 "$out")" = "$want" ]; then
echo "$(basename "$out"): already the pinned ${PLUGIN_VERSION} build"
return 0
fi
prepare
echo "Building session-manager-plugin ${PLUGIN_VERSION} for ${goos}/${goarch}"
( cd "$GOPATH_DIR/src/github.com/aws/session-manager-plugin" && \
go_env "$goos" "$goarch" "$GO" build -trimpath -buildvcs=false \
-ldflags "-s -w -buildid=" -o "$work/out-$triple" \
github.com/aws/session-manager-plugin/src/sessionmanagerplugin-main )
local got
got="$(sha256 "$work/out-$triple")"
[ "$got" = "$want" ] || die "the ${goos}/${goarch} build is not the pinned binary: got $got, pinned $want (source, toolchain or build flags changed)"
mkdir -p "$(dirname "$out")"
chmod 0755 "$work/out-$triple"
mv -f "$work/out-$triple" "$out"
echo "$(basename "$out"): session-manager-plugin ${PLUGIN_VERSION}"
}
build_universal() {
local lipo
lipo="$(command -v lipo || command -v llvm-lipo || true)"
[ -n "$lipo" ] || die "universal-apple-darwin needs lipo (Xcode command line tools) or llvm-lipo"
local x86="$dest_dir/session-manager-plugin-x86_64-apple-darwin"
local arm="$dest_dir/session-manager-plugin-aarch64-apple-darwin"
local uni="$dest_dir/session-manager-plugin-universal-apple-darwin"
build_thin x86_64-apple-darwin "$x86"
build_thin aarch64-apple-darwin "$arm"
"$lipo" -create "$x86" "$arm" -output "$work/universal"
# Each slice must come back out byte-identical to its pinned thin binary.
local pair arch triple
for pair in x86_64:x86_64-apple-darwin arm64:aarch64-apple-darwin; do
arch="${pair%%:*}" triple="${pair#*:}"
"$lipo" "$work/universal" -thin "$arch" -output "$work/slice-$arch"
[ "$(sha256 "$work/slice-$arch")" = "$(target_pin "$triple" | cut -d' ' -f3)" ] \
|| die "the $arch slice of the universal binary is not the pinned binary"
done
chmod 0755 "$work/universal"
mv -f "$work/universal" "$uni"
echo "$(basename "$uni"): session-manager-plugin ${PLUGIN_VERSION} (x86_64 + arm64)"
}
targets=("$@")
if [ ${#targets[@]} -eq 0 ]; then
host="$(rustc -vV 2>/dev/null | sed -n 's/^host: //p')"
[ -n "$host" ] || die "no target given and rustc is not available to name the host's"
targets=("$host")
fi
for t in "${targets[@]}"; do
case "$t" in
universal-apple-darwin) build_universal ;;
*-windows-*) build_thin "$t" "$dest_dir/session-manager-plugin-$t.exe" ;;
*) build_thin "$t" "$dest_dir/session-manager-plugin-$t" ;;
esac
done
+16
View File
@@ -317,6 +317,22 @@ if [ "$pw_removed" = true ]; then
fi fi
[ -x "$out/usr/bin/triple-c" ] || fail "no executable usr/bin/triple-c." [ -x "$out/usr/bin/triple-c" ] || fail "no executable usr/bin/triple-c."
# The bundled AWS Session Manager plugin (bundle.externalBin, built from
# source by build-ssm-plugin.sh) is what AWS workspaces connect through. Tauri copies it
# beside the app binary with the target triple stripped, which is where
# `host::ssm::find_plugin` looks. It must be the real plugin: an ELF, not the
# placeholder a debug build writes (build.rs refuses that for release, and this
# is the check on what actually shipped).
plugin="$out/usr/bin/session-manager-plugin"
[ -x "$plugin" ] || fail "no executable usr/bin/session-manager-plugin (the bundled AWS plugin)."
[ "$(head -c 4 "$plugin" | od -An -c | tr -d ' ')" = "177ELF" ] \
|| fail "usr/bin/session-manager-plugin is not an ELF binary (a placeholder?)."
"$plugin" --version >/dev/null 2>&1 \
|| fail "usr/bin/session-manager-plugin does not run (--version)."
# Its license and notices travel with it (bundle.resources).
notices=("$out"/usr/lib/*/THIRD_PARTY_NOTICES)
[ -f "${notices[0]}" ] || fail "THIRD_PARTY_NOTICES is not in the image."
# Every file readable by all, every program executable by all — what the # Every file readable by all, every program executable by all — what the
# `chmod -R a+rX` before the repack promised (AppRun.wrapped used to ship 0770). # `chmod -R a+rX` before the repack promised (AppRun.wrapped used to ship 0770).
# Files only: the AppImage runtime's --appimage-extract creates every # Files only: the AppImage runtime's --appimage-extract creates every
+10 -4
View File
@@ -10,9 +10,10 @@
# extension DLLs candle/light load, the NSIS plugins makensis embeds - and # extension DLLs candle/light load, the NSIS plugins makensis embeds - and
# each signature is metered (about 1000 a month), so those are skipped. The # each signature is metered (about 1000 a month), so those are skipped. The
# allowlist below is the whole of what reaches users: the app binary, the MSI, # allowlist below is the whole of what reaches users: the app binary, the MSI,
# the NSIS installer, and the uninstaller makensis writes to the job's temp # the NSIS installer, the uninstaller makensis writes to the job's temp
# directory. A file that already carries a valid signature is skipped too: # directory, and the session-manager-plugin sidecar we build from source. A
# Tauri presents the app binary once per bundle type. # file that already carries a valid signature is skipped too: Tauri presents
# the app binary once per bundle type.
# #
# This may run as 32-bit PowerShell: the NSIS uninstaller is signed from inside # This may run as 32-bit PowerShell: the NSIS uninstaller is signed from inside
# makensis, which is 32-bit and resolves `powershell` to the SysWOW64 copy. So # makensis, which is 32-bit and resolves `powershell` to the SysWOW64 copy. So
@@ -46,7 +47,12 @@ try {
$full = (Resolve-Path -LiteralPath $Path).ProviderPath $full = (Resolve-Path -LiteralPath $Path).ProviderPath
Write-Log "== $full" Write-Log "== $full"
$ships = ($full -match '\\target\\release\\[^\\]+\.exe$') -or # The bundled session-manager-plugin sidecar (bundle.externalBin), which we
# build from AWS's source (scripts/build-ssm-plugin.ps1) and so ship unsigned
# unless signed here. Tauri presents a sidecar to the sign command, in place
# under app\src-tauri\binaries, only when `signtool verify /pa` rejects it.
$ships = ($full -match '\\src-tauri\\binaries\\session-manager-plugin-x86_64-pc-windows-msvc\.exe$') -or
($full -match '\\target\\release\\[^\\]+\.exe$') -or
($full -match '\\target\\release\\bundle\\(msi|nsis)\\[^\\]+\.(msi|exe)$') -or ($full -match '\\target\\release\\bundle\\(msi|nsis)\\[^\\]+\.(msi|exe)$') -or
$full.StartsWith($env:TRIPLE_C_SIGN_TMP.TrimEnd('\') + '\', [StringComparison]::OrdinalIgnoreCase) $full.StartsWith($env:TRIPLE_C_SIGN_TMP.TrimEnd('\') + '\', [StringComparison]::OrdinalIgnoreCase)
if (-not $ships) { if (-not $ships) {
+50 -1
View File
@@ -14,6 +14,10 @@
# unpacked with an administrative install and its binaries checked directly; # unpacked with an administrative install and its binaries checked directly;
# the NSIS installer cannot be unpacked that way, so for it the signing log # the NSIS installer cannot be unpacked that way, so for it the signing log
# must show the app binary and the uninstaller were signed. # must show the app binary and the uninstaller were signed.
#
# The bundled session-manager-plugin (built from source, signed by us) is
# checked too: present in the MSI, and in both installers validly signed,
# timestamped, and by the same signing identity as the installer itself.
param([Parameter(Mandatory = $true, ValueFromRemainingArguments = $true)][string[]]$Patterns) param([Parameter(Mandatory = $true, ValueFromRemainingArguments = $true)][string[]]$Patterns)
@@ -47,6 +51,24 @@ function Test-Signature([IO.FileInfo]$File, [string]$Label) {
return $false return $false
} }
# The session-manager-plugin sidecar is built from AWS's source
# (build-ssm-plugin.ps1), so it is unsigned until windows-sign.ps1 signs it. It
# must carry OUR signature: valid, timestamped, and from the same signing
# identity (subject and issuer) as the installer that ships it.
$sidecarName = 'session-manager-plugin.exe'
$sidecarSource = Join-Path (Split-Path -Parent $PSScriptRoot) 'app\src-tauri\binaries\session-manager-plugin-x86_64-pc-windows-msvc.exe'
function Test-OurSigner([IO.FileInfo]$File, [string]$Label, [IO.FileInfo]$Installer) {
if (-not (Test-Signature $File $Label)) { return $false }
$ours = (Get-AuthenticodeSignature -FilePath $Installer.FullName).SignerCertificate
$theirs = (Get-AuthenticodeSignature -FilePath $File.FullName).SignerCertificate
# Subject + Issuer, not the thumbprint: Azure Artifact Signing issues a
# fresh short-lived certificate (daily), so the plugin and the installer
# can legitimately carry different thumbprints within one build.
if ($ours -and $theirs -and $ours.Subject -eq $theirs.Subject -and $ours.Issuer -eq $theirs.Issuer) { return $true }
Write-Host "FAIL $Label - signed by '$($theirs.Subject)' (issuer '$($theirs.Issuer)'), not the identity that signed $($Installer.Name)"
return $false
}
function Get-SignedLog { function Get-SignedLog {
if ($env:TRIPLE_C_SIGN_LOG -and (Test-Path $env:TRIPLE_C_SIGN_LOG)) { return @(Get-Content $env:TRIPLE_C_SIGN_LOG) } if ($env:TRIPLE_C_SIGN_LOG -and (Test-Path $env:TRIPLE_C_SIGN_LOG)) { return @(Get-Content $env:TRIPLE_C_SIGN_LOG) }
return @() return @()
@@ -56,7 +78,7 @@ $failed = @()
$nsisBuilt = $false $nsisBuilt = $false
foreach ($file in $files) { foreach ($file in $files) {
if (-not (Test-Signature $file $file.Name)) { $failed += $file.Name } if (-not (Test-Signature $file $file.Name)) { $failed += $file.Name }
if ($file.FullName -match '\\bundle\\nsis\\') { $nsisBuilt = $true } if ($file.FullName -match '\\bundle\\nsis\\') { $nsisBuilt = $true; $nsisInstaller = $file }
if ($file.Extension -eq '.msi') { if ($file.Extension -eq '.msi') {
$extract = Join-Path ([IO.Path]::GetTempPath()) ('msi-verify-' + [guid]::NewGuid().ToString('N')) $extract = Join-Path ([IO.Path]::GetTempPath()) ('msi-verify-' + [guid]::NewGuid().ToString('N'))
@@ -74,6 +96,21 @@ foreach ($file in $files) {
foreach ($f in $inner) { foreach ($f in $inner) {
if (-not (Test-Signature $f "$($file.Name) > $($f.Name)")) { $failed += "$($file.Name) > $($f.Name)" } if (-not (Test-Signature $f "$($file.Name) > $($f.Name)")) { $failed += "$($file.Name) > $($f.Name)" }
} }
# Its licence notices travel with it (bundle.resources).
if ($proc.ExitCode -eq 0 -and -not @(Get-ChildItem -Path $extract -Recurse -File -Filter 'THIRD_PARTY_NOTICES').Count) {
Write-Host "FAIL $($file.Name) - carries no THIRD_PARTY_NOTICES"
$failed += "$($file.Name) > THIRD_PARTY_NOTICES (missing)"
}
# The bundled plugin must be in there, under our signature.
if ($proc.ExitCode -eq 0) {
$plugin = @($inner | Where-Object { $_.Name -eq $sidecarName })
if ($plugin.Count -ne 1) {
Write-Host "FAIL $($file.Name) - carries $($plugin.Count) $sidecarName, expected 1"
$failed += "$($file.Name) > $sidecarName (missing)"
} elseif (-not (Test-OurSigner $plugin[0] "$($file.Name) > $sidecarName" $file)) {
$failed += "$($file.Name) > $sidecarName (signer)"
}
}
Remove-Item -Recurse -Force $extract -ErrorAction SilentlyContinue Remove-Item -Recurse -Force $extract -ErrorAction SilentlyContinue
} }
} }
@@ -92,6 +129,18 @@ if ($nsisBuilt) {
} else { } else {
Write-Host "OK app binary - signed before packaging ($($appSigned.Count)x)" Write-Host "OK app binary - signed before packaging ($($appSigned.Count)x)"
} }
# makensis packs the sidecar straight from app\src-tauri\binaries, where
# Tauri had it signed in place before any bundle: so that file, and a
# logged signature for it, are what NSIS shipped.
if (-not (Test-Path -LiteralPath $sidecarSource)) {
Write-Host "FAIL $sidecarName - $sidecarSource is missing"
$failed += "NSIS > $sidecarName (missing)"
} elseif (-not (Test-OurSigner (Get-Item -LiteralPath $sidecarSource) "NSIS > $sidecarName (as packed)" $nsisInstaller)) {
$failed += "NSIS > $sidecarName (signer)"
} elseif (-not @($log | Where-Object { $_ -match '\\src-tauri\\binaries\\session-manager-plugin-x86_64-pc-windows-msvc\.exe$' }).Count) {
Write-Host "FAIL $sidecarName - no signature was logged for it"
$failed += "NSIS > $sidecarName (not logged)"
}
$tmp = $env:TRIPLE_C_SIGN_TMP $tmp = $env:TRIPLE_C_SIGN_TMP
$uninstaller = @() $uninstaller = @()
if ($tmp) { $uninstaller = @($log | Where-Object { $_.StartsWith($tmp, [StringComparison]::OrdinalIgnoreCase) }) } if ($tmp) { $uninstaller = @($log | Where-Object { $_.StartsWith($tmp, [StringComparison]::OrdinalIgnoreCase) }) }