From bfe2d996d23efa84f7e52af5dc0f6a6e7c8e4673 Mon Sep 17 00:00:00 2001 From: Alex Hancock Date: Tue, 15 Sep 2026 13:52:36 -0400 Subject: [PATCH] feat(desktop): connect the external backend ACP socket to the redirect-resolved backend URL (#11829) --- ui/desktop/eslint.config.js | 1 + ui/desktop/src/acp/__tests__/url.test.ts | 21 -- ui/desktop/src/acp/url.ts | 17 +- ui/desktop/src/backendStatus.test.ts | 97 ------ ui/desktop/src/backendStatus.ts | 161 ---------- ui/desktop/src/main.ts | 27 +- ui/desktop/src/remoteBackends.test.ts | 174 +++++++++++ ui/desktop/src/remoteBackends.ts | 377 +++++++++++++++++++++++ ui/desktop/src/utils/csp.ts | 36 ++- 9 files changed, 602 insertions(+), 309 deletions(-) delete mode 100644 ui/desktop/src/backendStatus.test.ts delete mode 100644 ui/desktop/src/backendStatus.ts create mode 100644 ui/desktop/src/remoteBackends.test.ts create mode 100644 ui/desktop/src/remoteBackends.ts diff --git a/ui/desktop/eslint.config.js b/ui/desktop/eslint.config.js index cae0f57ea..f6fafd6df 100644 --- a/ui/desktop/eslint.config.js +++ b/ui/desktop/eslint.config.js @@ -91,6 +91,7 @@ module.exports = [ ReadableStreamDefaultController: 'readonly', WritableStream: 'readonly', AbortController: 'readonly', + AbortSignal: 'readonly', RequestCredentials: 'readonly', HeadersInit: 'readonly', KeyboardEvent: 'readonly', diff --git a/ui/desktop/src/acp/__tests__/url.test.ts b/ui/desktop/src/acp/__tests__/url.test.ts index b131401af..ab10b85a2 100644 --- a/ui/desktop/src/acp/__tests__/url.test.ts +++ b/ui/desktop/src/acp/__tests__/url.test.ts @@ -1,7 +1,6 @@ import { describe, expect, it } from 'vitest'; import { acpHttpUrlFromHttpBase, - acpWebSocketUrlFromHttpBase, httpBaseFromAcpWebSocketUrl, isLoopbackAcpWebSocketUrl, normalizeAcpHttpBaseUrl, @@ -110,24 +109,4 @@ describe('HTTP endpoint URLs from ACP HTTP base URLs', () => { 'https://example.com/goose/acp' ); }); - - it('adds ACP query tokens when provided', () => { - expect(acpHttpUrlFromHttpBase('https://example.com/goose', 'test secret')).toBe( - 'https://example.com/goose/acp?token=test+secret' - ); - }); -}); - -describe('acpWebSocketUrlFromHttpBase', () => { - it('derives WSS ACP URLs from HTTPS base URLs', () => { - expect(acpWebSocketUrlFromHttpBase('https://example.com/goose', 'secret')).toBe( - 'wss://example.com/goose/acp?token=secret' - ); - }); - - it('derives WS ACP URLs from HTTP base URLs', () => { - expect(acpWebSocketUrlFromHttpBase('http://127.0.0.1:1234', 'secret')).toBe( - 'ws://127.0.0.1:1234/acp?token=secret' - ); - }); }); diff --git a/ui/desktop/src/acp/url.ts b/ui/desktop/src/acp/url.ts index b3a2719a0..9e6e165a7 100644 --- a/ui/desktop/src/acp/url.ts +++ b/ui/desktop/src/acp/url.ts @@ -69,19 +69,6 @@ export function statusHttpUrlFromHttpBase(rawBaseUrl: string): string { return httpEndpointUrlFromHttpBase(rawBaseUrl, 'status'); } -export function acpHttpUrlFromHttpBase(rawBaseUrl: string, token?: string): string { - const url = new URL(httpEndpointUrlFromHttpBase(rawBaseUrl, 'acp')); - if (token) { - url.searchParams.set('token', token); - } - return url.toString(); -} - -export function acpWebSocketUrlFromHttpBase(rawBaseUrl: string, token: string): string { - const baseUrl = normalizeAcpHttpBaseUrl(rawBaseUrl); - const url = new URL(baseUrl); - url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'; - url.pathname = `${url.pathname.replace(/\/+$/, '')}/acp`; - url.searchParams.set('token', token); - return url.toString(); +export function acpHttpUrlFromHttpBase(rawBaseUrl: string): string { + return httpEndpointUrlFromHttpBase(rawBaseUrl, 'acp'); } diff --git a/ui/desktop/src/backendStatus.test.ts b/ui/desktop/src/backendStatus.test.ts deleted file mode 100644 index cd5600e7f..000000000 --- a/ui/desktop/src/backendStatus.test.ts +++ /dev/null @@ -1,97 +0,0 @@ -import { describe, expect, it, vi } from 'vitest'; -import { checkBackendStatus } from './backendStatus'; - -type FetchInput = Parameters[0]; - -const fetchInputUrl = (input: FetchInput): string => { - if (typeof input === 'string') { - return input; - } - if (input instanceof URL) { - return input.toString(); - } - return input.url; -}; - -describe('checkBackendStatus', () => { - it('checks /status and validates the secret against /acp', async () => { - const fetch = vi.fn(async (input: FetchInput) => { - const url = fetchInputUrl(input); - if (url === 'https://example.com/goose/status') { - return new Response(null, { status: 200 }); - } - if (url === 'https://example.com/goose/acp?token=test-secret') { - return new Response(null, { status: 406 }); - } - - throw new Error(`Unexpected URL: ${url}`); - }); - - await expect( - checkBackendStatus({ - baseUrl: 'https://example.com/goose', - serverSecret: 'test-secret', - fetch, - }) - ).resolves.toMatchObject({ ok: true, failure: null }); - - expect(fetch.mock.calls.map(([input]) => fetchInputUrl(input))).toEqual([ - 'https://example.com/goose/status', - 'https://example.com/goose/acp?token=test-secret', - ]); - }); - - it('reports the rejected secret without retrying', async () => { - const fetch = vi.fn(async (input: FetchInput) => { - const url = fetchInputUrl(input); - if (url === 'https://example.com/status') { - return new Response(null, { status: 200 }); - } - if (url === 'https://example.com/acp?token=wrong-secret') { - return new Response(null, { status: 401 }); - } - - throw new Error(`Unexpected URL: ${url}`); - }); - - const result = await checkBackendStatus({ - baseUrl: 'https://example.com', - serverSecret: 'wrong-secret', - fetch, - }); - - expect(result.ok).toBe(false); - expect(result.failure).toContain('Secret key: The backend rejected the secret key (HTTP 401)'); - expect(fetch).toHaveBeenCalledTimes(2); - }); - - it('reports an unusable URL without any request', async () => { - const fetch = vi.fn(); - - const result = await checkBackendStatus({ - baseUrl: 'https://example.com/acp', - serverSecret: 'test-secret', - fetch, - }); - - expect(result.ok).toBe(false); - expect(result.failure).toContain('URL:'); - expect(fetch).not.toHaveBeenCalled(); - }); - - it('stops retrying a fatal network failure', async () => { - const fetch = vi.fn(async () => { - throw new Error('net::ERR_NAME_NOT_RESOLVED'); - }); - - const result = await checkBackendStatus({ - baseUrl: 'https://nope.example.com', - serverSecret: 'test-secret', - fetch, - }); - - expect(result.ok).toBe(false); - expect(result.failure).toContain('ERR_NAME_NOT_RESOLVED'); - expect(fetch).toHaveBeenCalledTimes(1); - }); -}); diff --git a/ui/desktop/src/backendStatus.ts b/ui/desktop/src/backendStatus.ts deleted file mode 100644 index c54a3a365..000000000 --- a/ui/desktop/src/backendStatus.ts +++ /dev/null @@ -1,161 +0,0 @@ -import { - acpHttpUrlFromHttpBase, - normalizeAcpHttpBaseUrl, - statusHttpUrlFromHttpBase, -} from './acp/url'; - -const RETRY_BUDGET_MS = 15000; -const RETRY_INTERVAL_MS = 250; -const PROBE_TIMEOUT_MS = 5000; - -const FATAL_ERROR_PATTERN = /panicked at|RUST_BACKTRACE|fatal error/i; -const FATAL_NETWORK_PATTERN = /NAME_NOT_RESOLVED|CERT|SSL|CLIENT_AUTH|INVALID_URL|UNSAFE_PORT/; - -export interface BackendCheckStep { - name: string; - ok: boolean; - detail: string; -} - -export interface BackendCheckResult { - ok: boolean; - steps: BackendCheckStep[]; - failure: string | null; -} - -export interface BackendCheckParams { - baseUrl: string; - serverSecret: string; - fetch: typeof globalThis.fetch; - errorLog?: string[]; -} - -interface Probe { - ok: boolean; - detail: string; - retryable: boolean; -} - -const delay = (timeoutMs: number): Promise => - new Promise((resolve) => setTimeout(resolve, timeoutMs)); - -const errorText = (error: unknown): string => - error instanceof Error ? error.message : String(error); - -const proxyNote = (response: Response): string => { - const doormanError = response.headers.get('x-sq-cf-doorman-error'); - return doormanError && doormanError !== 'none' - ? ` A proxy in front of the backend reported "${doormanError}".` - : ''; -}; - -const request = async ( - fetch: typeof globalThis.fetch, - url: string, - init: Parameters[1], - expect: (response: Response) => Probe -): Promise => { - const controller = new AbortController(); - const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS); - try { - return expect(await fetch(url, { ...init, signal: controller.signal })); - } catch (error) { - const detail = errorText(error); - return { ok: false, detail, retryable: !FATAL_NETWORK_PATTERN.test(detail) }; - } finally { - clearTimeout(timeout); - } -}; - -const probeStatus = ( - fetch: typeof globalThis.fetch, - baseUrl: string, - secret: string -): Promise => - request( - fetch, - statusHttpUrlFromHttpBase(baseUrl), - { headers: { 'X-Secret-Key': secret } }, - (response) => - response.ok - ? { ok: true, detail: `GET /status returned ${response.status}.`, retryable: false } - : { - ok: false, - detail: `GET /status returned ${response.status} ${response.statusText}.${proxyNote(response)}`, - retryable: response.status >= 500, - } - ); - -const probeSecret = ( - fetch: typeof globalThis.fetch, - baseUrl: string, - secret: string -): Promise => - request(fetch, acpHttpUrlFromHttpBase(baseUrl, secret), {}, (response) => { - if (response.status === 406) { - return { ok: true, detail: 'The backend accepted the secret key.', retryable: false }; - } - if (response.status === 401 || response.status === 403) { - return { - ok: false, - detail: `The backend rejected the secret key (HTTP ${response.status}). It must match GOOSE_SERVER__SECRET_KEY on the backend.${proxyNote(response)}`, - retryable: false, - }; - } - return { - ok: false, - detail: `GET /acp returned ${response.status} ${response.statusText}, expected 406.${proxyNote(response)}`, - retryable: response.status >= 500, - }; - }); - -export const isFatalError = (line: string): boolean => FATAL_ERROR_PATTERN.test(line); - -export const checkBackendStatus = async ({ - baseUrl, - serverSecret, - fetch, - errorLog = [], -}: BackendCheckParams): Promise => { - const steps: BackendCheckStep[] = []; - - const run = async (name: string, probe: () => Promise): Promise => { - const deadline = Date.now() + RETRY_BUDGET_MS; - let result = await probe(); - while ( - !result.ok && - result.retryable && - Date.now() < deadline && - !errorLog.some(isFatalError) - ) { - await delay(RETRY_INTERVAL_MS); - result = await probe(); - } - steps.push({ name, ok: result.ok, detail: result.detail }); - return result.ok; - }; - - let normalizedBaseUrl = ''; - try { - normalizedBaseUrl = normalizeAcpHttpBaseUrl(baseUrl); - steps.push({ name: 'URL', ok: true, detail: normalizedBaseUrl }); - } catch (error) { - steps.push({ name: 'URL', ok: false, detail: errorText(error) }); - } - - if (normalizedBaseUrl) { - const reachable = await run('Reachable', () => - probeStatus(fetch, normalizedBaseUrl, serverSecret) - ); - if (reachable) { - await run('Secret key', () => probeSecret(fetch, normalizedBaseUrl, serverSecret)); - } - } - - const failed = steps.find((step) => !step.ok); - return { - ok: !failed, - steps, - failure: failed ? `${failed.name}: ${failed.detail}`.trim() : null, - }; -}; diff --git a/ui/desktop/src/main.ts b/ui/desktop/src/main.ts index 3771c6840..1d0391d90 100644 --- a/ui/desktop/src/main.ts +++ b/ui/desktop/src/main.ts @@ -26,13 +26,13 @@ import path from 'node:path'; import os from 'node:os'; import { execFileSync, spawn, execFile } from 'child_process'; import 'dotenv/config'; -import { checkBackendStatus } from './backendStatus'; +import { connectRemoteBackend } from './remoteBackends'; import { installBackendCertificateVerifiers } from './backendCertificateVerifier'; import { configureProxy } from './proxy'; import { startGooseServe } from './gooseServe'; import { getLoginShellPath } from './loginShellPath'; import { GooseServeLeaseRegistry, type GooseServeLease } from './gooseServeLeaseRegistry'; -import { acpWebSocketUrlFromHttpBase, normalizeAcpHttpBaseUrl } from './acp/url'; +import { normalizeAcpHttpBaseUrl } from './acp/url'; import { expandTilde, sanitizeGoosePathRoot } from './utils/pathUtils'; import log from './utils/logger'; import { ensureWinShims } from './utils/winShims'; @@ -59,7 +59,7 @@ import type { GooseApp } from './types/apps'; import installExtension, { REACT_DEVELOPER_TOOLS } from 'electron-devtools-installer'; import { WEB_PROTOCOLS } from './utils/urlSecurity'; import { openExternalUrl } from './utils/openExternalUrl'; -import { buildCSP } from './utils/csp'; +import { buildCSP, leaseBackendOrigin } from './utils/csp'; import { resolveWorkingDir } from './utils/workingDir'; import { DesktopFileAccess, @@ -1116,10 +1116,10 @@ const createChat = async ( ); } - const externalBackendCheck = await checkBackendStatus({ + const externalBackendCheck = await connectRemoteBackend({ baseUrl: externalBaseUrl, serverSecret, - fetch: net.fetch as unknown as typeof globalThis.fetch, + pinnedHostname: externalBackend.certFingerprint ? externalBase.hostname : null, }); if (!externalBackendCheck.ok) { externalCertificateTrust?.release(); @@ -1150,13 +1150,18 @@ const createChat = async ( return; } + const resolvedAcpUrl = externalBackendCheck.acpUrl; + if (!resolvedAcpUrl) { + throw new Error('External backend check did not resolve an ACP endpoint'); + } + + const originLease = leaseBackendOrigin(resolvedAcpUrl); const leaseCertificateTrust = externalCertificateTrust; externalCertificateTrust = null; - gooseServeLease = gooseServeLeases.createExternal( - acpWebSocketUrlFromHttpBase(externalBaseUrl, serverSecret), - serverSecret, - leaseCertificateTrust ? async () => leaseCertificateTrust.release() : undefined - ); + gooseServeLease = gooseServeLeases.createExternal(resolvedAcpUrl, serverSecret, async () => { + originLease.release(); + leaseCertificateTrust?.release(); + }); } catch (error) { externalCertificateTrust?.release(); log.error('External ACP backend is misconfigured', error); @@ -2478,7 +2483,7 @@ async function appMain() { // Add CSP headers to all sessions, recomputed on every response so external // backend settings take effect without restarting the app. - session.defaultSession.webRequest.onHeadersReceived((details, callback) => { + rendererSession.webRequest.onHeadersReceived((details, callback) => { const currentSettings = getSettings(); callback({ responseHeaders: { diff --git a/ui/desktop/src/remoteBackends.test.ts b/ui/desktop/src/remoteBackends.test.ts new file mode 100644 index 000000000..5f8a60fab --- /dev/null +++ b/ui/desktop/src/remoteBackends.test.ts @@ -0,0 +1,174 @@ +import { describe, expect, it, vi } from 'vitest'; +import { connectRemoteBackend, type RemoteBackendParams } from './remoteBackends'; + +type HopRequest = NonNullable; + +const respond = (status: number, location?: string) => ({ + status, + statusText: '', + header: () => null, + location: location ?? null, +}); + +describe('connectRemoteBackend', () => { + it('checks /status and validates the secret against /acp', async () => { + const request = vi.fn(async (url: string) => { + if (url === 'https://example.com/goose/status') { + return respond(200); + } + if (url === 'https://example.com/goose/acp') { + return respond(406); + } + + throw new Error(`Unexpected URL: ${url}`); + }); + + const result = await connectRemoteBackend({ + baseUrl: 'https://example.com/goose', + serverSecret: 'test-secret', + request, + }); + + expect(result).toMatchObject({ + ok: true, + failure: null, + acpUrl: 'wss://example.com/goose/acp?token=test-secret', + }); + }); + + it('follows redirects and keeps the resolved ACP endpoint', async () => { + const request = vi.fn(async (url: string) => { + if (url === 'https://example.com/status') { + return respond(302, 'https://backend.example.com/goose/status'); + } + if (url === 'https://backend.example.com/goose/status') { + return respond(200); + } + if (url === 'https://backend.example.com/goose/acp') { + return respond(302, 'https://backend.example.com/socket?tenant=x'); + } + if (url === 'https://backend.example.com/socket?tenant=x') { + return respond(406); + } + + throw new Error(`Unexpected URL: ${url}`); + }); + + const result = await connectRemoteBackend({ + baseUrl: 'https://example.com', + serverSecret: 'test-secret', + request, + }); + + expect(result.ok).toBe(true); + expect(result.acpUrl).toBe('wss://backend.example.com/socket?tenant=x&token=test-secret'); + }); + + it('sends the secret only to the resolved ACP endpoint', async () => { + const request = vi.fn(async (url) => { + if (url === 'https://example.com/status') { + return respond(200); + } + if (url === 'https://example.com/acp') { + return respond(302, 'https://backend.example.com/acp'); + } + if (url === 'https://backend.example.com/acp') { + return respond(406); + } + + throw new Error(`Unexpected URL: ${url}`); + }); + + await connectRemoteBackend({ + baseUrl: 'https://example.com', + serverSecret: 'test-secret', + request, + }); + + const secretRecipients = request.mock.calls + .filter(([, init]) => init.headers?.['X-Secret-Key']) + .map(([url]) => url); + expect(secretRecipients).toEqual(['https://backend.example.com/acp']); + }); + + it('rejects an HTTPS to HTTP redirect', async () => { + const request = vi.fn(async () => respond(302, 'http://backend.example.com/status')); + + const result = await connectRemoteBackend({ + baseUrl: 'https://example.com', + serverSecret: 'test-secret', + request, + }); + + expect(result.ok).toBe(false); + expect(result.failure).toContain('Redirect from HTTPS to HTTP is not allowed'); + expect(request).toHaveBeenCalledTimes(1); + }); + + it('rejects a cross-host redirect when a certificate fingerprint is pinned', async () => { + const request = vi.fn(async () => respond(302, 'https://backend.example.com/status')); + + const result = await connectRemoteBackend({ + baseUrl: 'https://example.com', + serverSecret: 'test-secret', + request, + pinnedHostname: 'example.com', + }); + + expect(result.ok).toBe(false); + expect(result.failure).toContain('certificate fingerprint is configured'); + }); + + it('reports the rejected secret without retrying', async () => { + const request = vi.fn(async (url: string) => { + if (url === 'https://example.com/status') { + return respond(200); + } + if (url === 'https://example.com/acp') { + return respond(401); + } + + throw new Error(`Unexpected URL: ${url}`); + }); + + const result = await connectRemoteBackend({ + baseUrl: 'https://example.com', + serverSecret: 'wrong-secret', + request, + }); + + expect(result.ok).toBe(false); + expect(result.failure).toContain('Secret key: The backend rejected the secret key (HTTP 401)'); + expect(request).toHaveBeenCalledTimes(3); + }); + + it('reports an unusable URL without any request', async () => { + const request = vi.fn(); + + const result = await connectRemoteBackend({ + baseUrl: 'https://example.com/acp', + serverSecret: 'test-secret', + request, + }); + + expect(result.ok).toBe(false); + expect(result.failure).toContain('URL:'); + expect(request).not.toHaveBeenCalled(); + }); + + it('stops retrying a fatal network failure', async () => { + const request = vi.fn(async () => { + throw new Error('net::ERR_NAME_NOT_RESOLVED'); + }); + + const result = await connectRemoteBackend({ + baseUrl: 'https://nope.example.com', + serverSecret: 'test-secret', + request, + }); + + expect(result.ok).toBe(false); + expect(result.failure).toContain('ERR_NAME_NOT_RESOLVED'); + expect(request).toHaveBeenCalledTimes(1); + }); +}); diff --git a/ui/desktop/src/remoteBackends.ts b/ui/desktop/src/remoteBackends.ts new file mode 100644 index 000000000..4f7596f0d --- /dev/null +++ b/ui/desktop/src/remoteBackends.ts @@ -0,0 +1,377 @@ +import { net } from 'electron'; +import { + acpHttpUrlFromHttpBase, + normalizeAcpHttpBaseUrl, + statusHttpUrlFromHttpBase, +} from './acp/url'; + +const RETRY_BUDGET_MS = 15000; +const RETRY_INTERVAL_MS = 250; +const PROBE_TIMEOUT_MS = 5000; +const MAX_REDIRECT_HOPS = 20; + +const FATAL_ERROR_PATTERN = /panicked at|RUST_BACKTRACE|fatal error/i; +const FATAL_NETWORK_PATTERN = /NAME_NOT_RESOLVED|CERT|SSL|CLIENT_AUTH|INVALID_URL|UNSAFE_PORT/; + +export interface RemoteBackendStep { + name: string; + ok: boolean; + detail: string; +} + +export interface RemoteBackendConnection { + ok: boolean; + steps: RemoteBackendStep[]; + failure: string | null; + acpUrl: string | null; +} + +export interface RemoteBackendParams { + baseUrl: string; + serverSecret: string; + pinnedHostname?: string | null; + errorLog?: string[]; + request?: HopRequest; +} + +interface HopInit { + headers?: Record; + signal?: AbortSignal; +} + +interface Hop { + status: number; + statusText: string; + header(name: string): string | null; + location: string | null; +} + +type HopRequest = (url: string, init: HopInit) => Promise; + +const headerValue = (headers: Record, name: string): string | null => { + const value = headers[name.toLowerCase()]; + if (value === undefined) { + return null; + } + return Array.isArray(value) ? (value[0] ?? null) : value; +}; + +// net.fetch reports an incorrect Response.url, so each hop is issued separately +// with net.request and this module decides whether to follow it. +const netHopRequest: HopRequest = (url, init) => + new Promise((resolve, reject) => { + const request = net.request({ method: 'GET', url, redirect: 'manual', credentials: 'omit' }); + let settled = false; + + const abort = () => request.abort(); + init.signal?.addEventListener('abort', abort, { once: true }); + + const settle = (finish: () => void) => { + if (settled) { + return; + } + settled = true; + init.signal?.removeEventListener('abort', abort); + finish(); + }; + + // A manual redirect is not followed, so the request is cancelled after this + // event and only the 'abort' event follows. + request.on('redirect', (statusCode, _method, redirectUrl, responseHeaders) => { + settle(() => + resolve({ + status: statusCode, + statusText: '', + header: (name) => headerValue(responseHeaders, name), + location: redirectUrl, + }) + ); + request.abort(); + }); + + request.on('response', (response) => { + response.on('data', () => undefined); + response.on('end', () => + settle(() => + resolve({ + status: response.statusCode, + statusText: response.statusMessage, + header: (name) => headerValue(response.headers, name), + location: null, + }) + ) + ); + response.on('error', (error: Error) => settle(() => reject(error))); + }); + + request.on('error', (error) => settle(() => reject(error))); + request.on('abort', () => settle(() => reject(new Error('Request aborted')))); + + for (const [name, value] of Object.entries(init.headers ?? {})) { + request.setHeader(name, value); + } + request.end(); + }); + +class RedirectError extends Error {} + +const isRedirect = (status: number): boolean => + status === 301 || status === 302 || status === 303 || status === 307 || status === 308; + +const checkHop = (from: URL, to: URL, pinnedHostname: string | null): void => { + if (to.protocol !== 'http:' && to.protocol !== 'https:') { + throw new RedirectError(`Redirect to ${to.protocol} is not allowed, only http: and https:.`); + } + if (from.protocol === 'https:' && to.protocol === 'http:') { + throw new RedirectError( + `Redirect from HTTPS to HTTP is not allowed (${from.origin} to ${to.origin}).` + ); + } + if (pinnedHostname && to.hostname.toLowerCase() !== pinnedHostname) { + throw new RedirectError( + `Redirect to ${to.hostname} is not allowed because a certificate fingerprint is configured for ${pinnedHostname}.` + ); + } +}; + +const resolveRedirects = async ( + request: HopRequest, + startUrl: string, + pinnedHostname: string | null, + init: HopInit +): Promise<{ url: string; hop: Hop }> => { + let url = new URL(startUrl); + + for (let hopCount = 0; ; hopCount += 1) { + const hop = await request(url.toString(), init); + if (!isRedirect(hop.status)) { + return { url: url.toString(), hop }; + } + + if (hopCount >= MAX_REDIRECT_HOPS) { + throw new RedirectError(`Exceeded ${MAX_REDIRECT_HOPS} redirects starting at ${startUrl}.`); + } + if (!hop.location) { + throw new RedirectError(`Redirect from ${url.toString()} has no Location header.`); + } + + const next = new URL(hop.location, url); + checkHop(url, next, pinnedHostname); + url = next; + } +}; + +interface Probe { + ok: boolean; + detail: string; + retryable: boolean; + resolvedUrl?: string; +} + +const delay = (timeoutMs: number): Promise => + new Promise((resolve) => setTimeout(resolve, timeoutMs)); + +const errorText = (error: unknown): string => + error instanceof Error ? error.message : String(error); + +const proxyNote = (hop: Hop): string => { + const doormanError = hop.header('x-sq-cf-doorman-error'); + return doormanError && doormanError !== 'none' + ? ` A proxy in front of the backend reported "${doormanError}".` + : ''; +}; + +// Redirects are resolved anonymously; only the resolved URL is re-requested +// with the secret, so no intermediate origin ever sees it. +const probe = async ( + request: HopRequest, + url: string, + pinnedHostname: string | null, + credentials: Record | null, + expect: (hop: Hop, resolvedUrl: string) => Probe +): Promise => { + const controller = new AbortController(); + const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS); + try { + const { url: resolvedUrl, hop } = await resolveRedirects(request, url, pinnedHostname, { + signal: controller.signal, + }); + const finalHop = credentials + ? await request(resolvedUrl, { headers: credentials, signal: controller.signal }) + : hop; + return expect(finalHop, resolvedUrl); + } catch (error) { + const detail = errorText(error); + return { + ok: false, + detail, + retryable: !(error instanceof RedirectError) && !FATAL_NETWORK_PATTERN.test(detail), + }; + } finally { + clearTimeout(timeout); + } +}; + +const probeStatus = ( + request: HopRequest, + baseUrl: string, + pinnedHostname: string | null +): Promise => + probe(request, statusHttpUrlFromHttpBase(baseUrl), pinnedHostname, null, (hop, resolvedUrl) => + hop.status >= 200 && hop.status < 300 + ? { + ok: true, + detail: `GET /status returned ${hop.status}.`, + retryable: false, + resolvedUrl, + } + : { + ok: false, + detail: `GET /status returned ${hop.status} ${hop.statusText}.${proxyNote(hop)}`, + retryable: hop.status >= 500, + } + ); + +const probeAcp = ( + request: HopRequest, + baseUrl: string, + secret: string, + pinnedHostname: string | null +): Promise => + probe( + request, + acpHttpUrlFromHttpBase(baseUrl), + pinnedHostname, + { 'X-Secret-Key': secret }, + (hop, resolvedUrl) => { + if (hop.status === 406) { + return { + ok: true, + detail: 'The backend accepted the secret key.', + retryable: false, + resolvedUrl, + }; + } + if (hop.status === 401 || hop.status === 403) { + return { + ok: false, + detail: `The backend rejected the secret key (HTTP ${hop.status}). It must match GOOSE_SERVER__SECRET_KEY on the backend.${proxyNote(hop)}`, + retryable: false, + }; + } + return { + ok: false, + detail: `GET /acp returned ${hop.status} ${hop.statusText}, expected 406.${proxyNote(hop)}`, + retryable: hop.status >= 500, + }; + } + ); + +const baseUrlFromStatusUrl = (statusUrl: string): string | null => { + const url = new URL(statusUrl); + const pathname = url.pathname.replace(/\/+$/, ''); + return pathname.endsWith('/status') + ? `${url.origin}${pathname.slice(0, -'/status'.length)}` + : null; +}; + +// The resolved endpoint is kept whole, including any query parameters a proxy +// added, so the socket connects exactly where the probe succeeded. +const acpWebSocketUrl = (acpUrl: string, secret: string): string => { + const url = new URL(acpUrl); + url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'; + url.hash = ''; + url.searchParams.set('token', secret); + return url.toString(); +}; + +const isFatalError = (line: string): boolean => FATAL_ERROR_PATTERN.test(line); + +export const connectRemoteBackend = async ({ + baseUrl, + serverSecret, + pinnedHostname = null, + errorLog = [], + request = netHopRequest, +}: RemoteBackendParams): Promise => { + const steps: RemoteBackendStep[] = []; + const pin = pinnedHostname?.toLowerCase() ?? null; + + const run = async (name: string, attempt: () => Promise): Promise => { + const deadline = Date.now() + RETRY_BUDGET_MS; + let result = await attempt(); + while ( + !result.ok && + result.retryable && + Date.now() < deadline && + !errorLog.some(isFatalError) + ) { + await delay(RETRY_INTERVAL_MS); + result = await attempt(); + } + steps.push({ name, ok: result.ok, detail: result.detail }); + return result; + }; + + let normalizedBaseUrl = ''; + try { + normalizedBaseUrl = normalizeAcpHttpBaseUrl(baseUrl); + steps.push({ name: 'URL', ok: true, detail: normalizedBaseUrl }); + } catch (error) { + steps.push({ name: 'URL', ok: false, detail: errorText(error) }); + } + + const resolve = async (): Promise => { + if (!normalizedBaseUrl) { + return null; + } + + const reachable = await run('Reachable', () => probeStatus(request, normalizedBaseUrl, pin)); + if (!reachable.ok || !reachable.resolvedUrl) { + return null; + } + + const resolvedBaseUrl = baseUrlFromStatusUrl(reachable.resolvedUrl); + if (!resolvedBaseUrl) { + steps.push({ + name: 'Redirect', + ok: false, + detail: `/status resolved to ${reachable.resolvedUrl}, so the ACP path cannot be derived from it.`, + }); + return null; + } + if (resolvedBaseUrl !== normalizedBaseUrl) { + steps.push({ name: 'Redirect', ok: true, detail: `Followed to ${resolvedBaseUrl}.` }); + } + + const accepted = await run('Secret key', () => + probeAcp(request, resolvedBaseUrl, serverSecret, pin) + ); + if (!accepted.ok || !accepted.resolvedUrl) { + return null; + } + + const statusOrigin = new URL(resolvedBaseUrl).origin; + const acpOrigin = new URL(accepted.resolvedUrl).origin; + if (statusOrigin !== acpOrigin) { + steps.push({ + name: 'Redirect', + ok: false, + detail: `/status and /acp resolved to different origins (${statusOrigin} and ${acpOrigin}).`, + }); + return null; + } + + return acpWebSocketUrl(accepted.resolvedUrl, serverSecret); + }; + + const acpUrl = await resolve(); + + const failed = steps.find((step) => !step.ok); + return { + ok: !failed, + steps, + failure: failed ? `${failed.name}: ${failed.detail}`.trim() : null, + acpUrl: failed ? null : acpUrl, + }; +}; diff --git a/ui/desktop/src/utils/csp.ts b/ui/desktop/src/utils/csp.ts index 89b066c2a..81f9ef228 100644 --- a/ui/desktop/src/utils/csp.ts +++ b/ui/desktop/src/utils/csp.ts @@ -15,8 +15,31 @@ const DEFAULT_CONNECT_SOURCES = [ 'https://objects.githubusercontent.com', ]; +export interface BackendOriginLease { + release: () => void; +} + +interface LeasedBackendOrigin { + origin: string; + insecure: boolean; +} + +const leasedBackendOrigins = new Set(); + +// A redirected backend serves ACP from an origin the settings do not name, so +// the renderer needs it in connect-src for as long as a window uses it. +export function leaseBackendOrigin(acpUrl: string): BackendOriginLease { + const url = new URL(acpUrl); + const leased: LeasedBackendOrigin = { origin: url.origin, insecure: url.protocol === 'ws:' }; + leasedBackendOrigins.add(leased); + return { release: () => leasedBackendOrigins.delete(leased) }; +} + export function buildConnectSrc(externalBackend?: ExternalBackendConfig): string { - const sources = [...DEFAULT_CONNECT_SOURCES]; + const sources = [ + ...DEFAULT_CONNECT_SOURCES, + ...[...leasedBackendOrigins].map((leased) => leased.origin), + ]; if (externalBackend?.enabled && externalBackend.url) { try { @@ -36,14 +59,19 @@ export function buildConnectSrc(externalBackend?: ExternalBackendConfig): string * Returns true when upgrade-insecure-requests should be included in the CSP. * * The directive is omitted when the user has configured an external backend - * that uses plain HTTP, because Chromium would silently rewrite those - * requests to HTTPS. The remote server typically does not speak TLS, so the - * upgraded requests fail with "Failed to fetch". + * that uses plain HTTP, or when a leased backend was resolved to plain HTTP, + * because Chromium would silently rewrite those requests to HTTPS. The remote + * server typically does not speak TLS, so the upgraded requests fail with + * "Failed to fetch". * * Loopback addresses (127.0.0.1 / localhost) are exempt from the upgrade * per the CSP spec, which is why the built-in local backend is unaffected. */ export function shouldUpgradeInsecureRequests(externalBackend?: ExternalBackendConfig): boolean { + if ([...leasedBackendOrigins].some((leased) => leased.insecure)) { + return false; + } + if (!externalBackend?.enabled || !externalBackend.url) { return true; }