diff --git a/apps/desktop/src/app/DesktopApp.ts b/apps/desktop/src/app/DesktopApp.ts index 0064eb99a5c14..8d1a9f041d691 100644 --- a/apps/desktop/src/app/DesktopApp.ts +++ b/apps/desktop/src/app/DesktopApp.ts @@ -200,7 +200,8 @@ const startLocalBackend = Effect.gen(function* () { return false; } - const primaryBackend = yield* (yield* DesktopBackendPool.DesktopBackendPool).primary; + const pool = yield* DesktopBackendPool.DesktopBackendPool; + const primaryBackend = yield* pool.primary; const serverExposure = yield* DesktopServerExposure.DesktopServerExposure; if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) { @@ -212,16 +213,8 @@ const startLocalBackend = Effect.gen(function* () { !(settings.wslOnly && settings.wslBackendEnabled) && !(yield* DesktopHomeOwner.awaitHomeOwnershipRelease()) ) { - const owner = yield* DesktopHomeOwner.readLiveHomeOwner(); - yield* logBootstrapWarning("bootstrap found another server owning the T3 home", { - owner: Option.getOrNull(owner), - }); - yield* (yield* ElectronDialog.ElectronDialog).showErrorBox( - "This T3 home is unavailable", - DesktopHomeOwner.homeOwnedMessage(owner), - ); - yield* (yield* ElectronApp.ElectronApp).quit; - return false; + yield* logBootstrapInfo("connecting to the server that owns the T3 home"); + return yield* pool.connectToHomeOwner; } const backendPortSelection = yield* resolveDesktopBackendPort(environment.configuredBackendPort); diff --git a/apps/desktop/src/backend/DesktopBackendPool.test.ts b/apps/desktop/src/backend/DesktopBackendPool.test.ts index 005a1cde1224a..26948f1a0606e 100644 --- a/apps/desktop/src/backend/DesktopBackendPool.test.ts +++ b/apps/desktop/src/backend/DesktopBackendPool.test.ts @@ -1,3 +1,4 @@ +import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; import { assert, describe, it } from "@effect/vitest"; import { DESKTOP_UPDATE_IN_PROGRESS_TTL_MS } from "@t3tools/contracts"; import * as Deferred from "effect/Deferred"; @@ -19,6 +20,7 @@ import { ChildProcessSpawner } from "effect/process"; import * as DesktopConfig from "../app/DesktopConfig.ts"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; import * as DesktopObservability from "../app/DesktopObservability.ts"; +import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts"; import * as DesktopState from "../app/DesktopState.ts"; import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; import * as DesktopTelemetryPublisher from "../telemetry/DesktopTelemetryPublisher.ts"; @@ -194,6 +196,8 @@ function layerPool( currentBootstrapToken: Effect.die("unexpected bootstrap token read"), } satisfies DesktopBackendConfiguration.DesktopBackendConfiguration["Service"]), DesktopAppSettings.layerTest(), + DesktopManagedPolicy.layerTest(), + NodeCrypto.layer, DesktopState.layer, DesktopWslEnvironment.layerTest(), Layer.succeed(ElectronDialog.ElectronDialog, { diff --git a/apps/desktop/src/backend/DesktopBackendPool.ts b/apps/desktop/src/backend/DesktopBackendPool.ts index 62c811996b1a0..65661bdc862de 100644 --- a/apps/desktop/src/backend/DesktopBackendPool.ts +++ b/apps/desktop/src/backend/DesktopBackendPool.ts @@ -3,6 +3,7 @@ import { DESKTOP_UPDATE_IN_PROGRESS_TTL_MS, } from "@t3tools/contracts"; import * as Context from "effect/Context"; +import * as SecureRandom from "effect/crypto/SecureRandom"; import * as Deferred from "effect/Deferred"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; @@ -11,6 +12,7 @@ import * as FiberHandle from "effect/FiberHandle"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; +import * as Ref from "effect/Ref"; import * as Schedule from "effect/Schedule"; import * as Schema from "effect/Schema"; import * as Scope from "effect/Scope"; @@ -26,6 +28,7 @@ import * as DesktopBackendManager from "./DesktopBackendManager.ts"; import * as DesktopHomeOwner from "./DesktopHomeOwner.ts"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; import * as DesktopObservability from "../app/DesktopObservability.ts"; +import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts"; import * as DesktopState from "../app/DesktopState.ts"; import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; import * as DesktopTelemetryPublisher from "../telemetry/DesktopTelemetryPublisher.ts"; @@ -74,6 +77,8 @@ export class DesktopBackendPool extends Context.Service< readonly get: (id: BackendInstanceId) => Effect.Effect>; readonly list: Effect.Effect; readonly primary: Effect.Effect; + readonly attachedHomeOwner: Effect.Effect>; + readonly connectToHomeOwner: Effect.Effect; readonly register: ( spec: BackendInstanceSpec, ) => Effect.Effect; @@ -129,7 +134,12 @@ export const layer = Layer.effect( const layerScope = yield* Scope.Scope; const factoryContext = yield* Effect.context(); const homeOwnerContext = yield* Effect.context< - FileSystem.FileSystem | Path.Path | DesktopEnvironment.DesktopEnvironment + | FileSystem.FileSystem + | Path.Path + | DesktopEnvironment.DesktopEnvironment + | DesktopManagedPolicy.DesktopManagedPolicy + | SecureRandom.SecureRandom + | ChildProcessSpawner.ChildProcessSpawner >(); const updateMarkerPath = environment.path.join( @@ -219,6 +229,32 @@ export const layer = Layer.effect( }, ); + const attachedHomeOwner = yield* Ref.make(Option.none()); + const connectToHomeOwner = Effect.gen(function* () { + const owner = yield* DesktopHomeOwner.readLiveHomeOwner(); + const session = Option.isSome(owner) + ? yield* DesktopHomeOwner.authenticateHomeOwner(owner.value) + : Option.none(); + if (Option.isNone(session)) { + yield* electronDialog.showErrorBox( + "This T3 home is unavailable", + DesktopHomeOwner.homeOwnedMessage(owner), + ); + yield* electronApp.quit; + return false; + } + yield* Ref.set(attachedHomeOwner, session); + yield* reloadStaleMain; + yield* desktopWindow.handleBackendReady(new URL(`http://127.0.0.1:${session.value.port}/`)); + yield* SubscriptionRef.set(primaryBackendStartup, { _tag: "Ready" }); + return true; + }).pipe( + Scope.provide(layerScope), + Effect.provideContext(homeOwnerContext), + Effect.orDie, + Effect.withSpan("desktop.backendPool.connectToHomeOwner"), + ); + const primary = yield* DesktopBackendManager.makeBackendInstance({ id: DesktopBackendManager.PRIMARY_INSTANCE_ID, // Resolve lazily: startup loads persisted settings after pool initialization. @@ -244,17 +280,11 @@ export const layer = Layer.effect( Effect.andThen(desktopWindow.handleBackendNotReady), ), onPreflightFailed: handlePrimaryPreflightFailure, - onStateDirOwned: () => - DesktopHomeOwner.readLiveHomeOwner().pipe( - Effect.flatMap((owner) => - electronDialog.showErrorBox( - "This T3 home is unavailable", - DesktopHomeOwner.homeOwnedMessage(owner), - ), - ), - Effect.provideContext(homeOwnerContext), - Effect.andThen(electronApp.quit), - ), + onStateDirOwned: () => { + // The window may already have read the endpoint selected for the child that lost the lock. + reloadMainOnReady = true; + return connectToHomeOwner.pipe(Effect.asVoid); + }, }); const instancesRef = yield* SynchronizedRef.make< @@ -389,6 +419,8 @@ export const layer = Layer.effect( ), ), primary: Effect.succeed(primary), + attachedHomeOwner: Ref.get(attachedHomeOwner), + connectToHomeOwner, register, unregister, }); @@ -414,6 +446,8 @@ export const layerTest = ( }), list: Effect.succeed(Array.from(byId.values())), primary: Effect.succeed(primary), + attachedHomeOwner: Effect.succeedNone, + connectToHomeOwner: Effect.die("unexpected home owner"), register: Effect.fn("DesktopBackendPool.register")(function () { return Effect.die("DesktopBackendPool.layerTest does not support register"); }), diff --git a/apps/desktop/src/backend/DesktopHomeOwner.test.ts b/apps/desktop/src/backend/DesktopHomeOwner.test.ts index f0b0df159272b..5df350ec9de82 100644 --- a/apps/desktop/src/backend/DesktopHomeOwner.test.ts +++ b/apps/desktop/src/backend/DesktopHomeOwner.test.ts @@ -1,6 +1,11 @@ +// @effect-diagnostics nodeBuiltinImport:off -- The fixture signs a challenge on the actual TCP listener the desktop verifies. +import * as NodeCrypto from "node:crypto"; +import * as NodeHttp from "node:http"; import * as NodeSqlite from "node:sqlite"; +import * as NodeCryptoServices from "@effect/platform-node/NodeCrypto"; import * as NodeServices from "@effect/platform-node/NodeServices"; +import { lanDiscoveryProofMessage } from "@t3tools/contracts"; import { assert, describe, it } from "@effect/vitest"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; @@ -12,15 +17,16 @@ import * as TestClock from "effect/testing/TestClock"; import * as DesktopConfig from "../app/DesktopConfig.ts"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; +import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts"; import * as DesktopHomeOwner from "./DesktopHomeOwner.ts"; -const withTempHome = ( +const withTempHome = ( run: ( userdata: string, ) => Effect.Effect< A, E, - DesktopEnvironment.DesktopEnvironment | FileSystem.FileSystem | Path.Path + DesktopEnvironment.DesktopEnvironment | FileSystem.FileSystem | Path.Path | R >, ) => Effect.gen(function* () { @@ -35,7 +41,7 @@ const withTempHome = ( platform: "linux", processArch: "x64", appVersion: "0.0.0", - appPath: "/repo", + appPath: home, isPackaged: true, resourcesPath: "/missing/resources", runningUnderArm64Translation: false, @@ -120,3 +126,98 @@ describe("DesktopHomeOwner.awaitHomeOwnershipRelease", () => { ), ); }); + +describe("DesktopHomeOwner.authenticateHomeOwner", () => { + it.live("attaches only to the home that signed the session and revokes it at exit", () => + withTempHome((userdata) => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const env = yield* DesktopEnvironment.DesktopEnvironment; + const environmentId = "bde15824-93d9-4339-a70a-599fcbe36b27"; + const sessionId = "9f907b0c-c099-47b3-8568-eb4594cf5ef1"; + const key = Buffer.alloc(32, 1); + const token = `YQ.${key.toString("base64url")}`; + yield* fs.makeDirectory(env.path.dirname(env.backendEntryPath), { recursive: true }); + yield* fs.writeFileString(env.path.join(userdata, "environment-id"), environmentId); + yield* fs.writeFileString( + env.backendEntryPath, + ` + import { appendFileSync } from "node:fs"; + const args = process.argv.slice(2); + const home = args[args.indexOf("--base-dir") + 1]; + appendFileSync(home + "/commands", args.slice(0, 3).join(" ") + "\\n"); + if (args[2] === "issue") console.log(JSON.stringify(${JSON.stringify({ sessionId, token })})); + else if (!args.includes("${sessionId}")) process.exit(1); + `, + ); + + let correctHome = false; + const server = NodeHttp.createServer(async (request, response) => { + const chunks = []; + for await (const chunk of request) chunks.push(chunk); + const { nonce, payload } = JSON.parse(Buffer.concat(chunks).toString()); + const address = server.address(); + if (!address || typeof address === "string" || payload !== "YQ") { + response.writeHead(400).end(); + return; + } + const proof = NodeCrypto.createHmac("sha256", correctHome ? key : Buffer.alloc(32, 2)) + .update(lanDiscoveryProofMessage(nonce, environmentId, "127.0.0.1", address.port)) + .digest("base64url"); + response.end(JSON.stringify({ proof })); + }); + yield* Effect.acquireRelease( + Effect.promise( + () => new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)), + ), + () => + Effect.promise( + () => + new Promise((resolve) => { + server.close(() => resolve()); + server.closeAllConnections(); + }), + ), + ); + const address = server.address(); + assert(address !== null && typeof address !== "string"); + const legacy = { pid: process.pid, port: address.port }; + assert.isTrue(Option.isNone(yield* DesktopHomeOwner.authenticateHomeOwner(legacy))); + const owner = { ...legacy, managedPolicy: null }; + const attach = DesktopHomeOwner.authenticateHomeOwner(owner); + assert.isTrue( + Option.isNone( + yield* attach.pipe( + Effect.provide( + DesktopManagedPolicy.layerTest({ + schemaVersion: 1, + organization: "Managed", + }), + ), + ), + ), + ); + assert.isTrue( + Option.isNone( + yield* DesktopHomeOwner.authenticateHomeOwner({ + ...owner, + managedPolicy: { organization: "Managed" }, + }), + ), + ); + assert.isTrue(Option.isNone(yield* attach)); + correctHome = true; + assert.deepEqual(yield* Effect.scoped(attach), Option.some({ port: address.port, token })); + assert.deepEqual( + (yield* fs.readFileString(env.path.join(env.baseDir, "commands"))).trim().split("\n"), + [ + "auth session issue", + "auth session revoke", + "auth session issue", + "auth session revoke", + ], + ); + }).pipe(Effect.provide([DesktopManagedPolicy.layerTest(), NodeCryptoServices.layer])), + ), + ); +}); diff --git a/apps/desktop/src/backend/DesktopHomeOwner.ts b/apps/desktop/src/backend/DesktopHomeOwner.ts index c4a59bc6707e0..66b92e0ad5165 100644 --- a/apps/desktop/src/backend/DesktopHomeOwner.ts +++ b/apps/desktop/src/backend/DesktopHomeOwner.ts @@ -1,15 +1,23 @@ // @effect-diagnostics nodeBuiltinImport:off - Probes the server's native SQLite ownership lock. import * as NodeSqlite from "node:sqlite"; +import { verifyLoopbackDiscoveryProof } from "@t3tools/client-runtime/connection"; +import { AuthSessionId } from "@t3tools/contracts"; import { CLI_RELEASES_PAGE_URL } from "@t3tools/shared/cliRelease"; +import * as Hex from "effect/encoding/Hex"; +import * as SecureRandom from "effect/crypto/SecureRandom"; +import * as Exit from "effect/Exit"; +import * as Scope from "effect/Scope"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; +import { ChildProcess, ChildProcessSpawner } from "effect/process"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; +import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts"; import { BACKEND_QUIT_STOP_TIMEOUT } from "./DesktopBackendManager.ts"; // The fields of the server's `server-runtime.json` that identify the owner of a T3 home. @@ -18,6 +26,7 @@ const HomeOwnerRuntimeState = Schema.Struct({ port: Schema.Int, serviceManaged: Schema.optional(Schema.Boolean), serverVersion: Schema.optional(Schema.String), + managedPolicy: Schema.optional(Schema.NullOr(Schema.Unknown)), }); export type HomeOwner = typeof HomeOwnerRuntimeState.Type; @@ -90,6 +99,89 @@ export const readLiveHomeOwner = Effect.fn("DesktopHomeOwner.readLiveHomeOwner") ); }); +const decodeSession = Schema.decodeUnknownEffect( + Schema.fromJsonString(Schema.Struct({ sessionId: AuthSessionId, token: Schema.String })), +); + +export type HomeOwnerSession = { readonly port: number; readonly token: string }; + +export const authenticateHomeOwner = Effect.fn("DesktopHomeOwner.authenticateHomeOwner")( + function* (owner: HomeOwner) { + const environment = yield* DesktopEnvironment.DesktopEnvironment; + if ( + environment.isDevelopment || + owner.port < 1 || + owner.port > 65535 || + owner.managedPolicy !== null + ) { + return Option.none(); + } + // Only the server can attest its enforced policy. A separately launched CLI cannot. + if (yield* (yield* DesktopManagedPolicy.DesktopManagedPolicy).read) + return Option.none(); + const fs = yield* FileSystem.FileSystem; + const environmentId = (yield* fs.readFileString( + environment.path.join(environment.stateDir, "environment-id"), + )).trim(); + if (!environmentId) return Option.none(); + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + const sessionCommand = (args: ReadonlyArray) => + spawner + .string( + ChildProcess.make( + process.execPath, + [ + environment.backendEntryPath, + "auth", + "session", + ...args, + "--base-dir", + environment.baseDir, + ], + { + env: { ELECTRON_RUN_AS_NODE: "1" }, + extendEnv: true, + stdin: "ignore", + stderr: "ignore", + }, + ), + ) + .pipe(Effect.timeout("15 seconds")); + const nonce = Hex.encode(yield* (yield* SecureRandom.SecureRandom).randomBytes(32)); + const desktopScope = yield* Scope.Scope; + return yield* Effect.acquireUseRelease( + sessionCommand(["issue", "--label", "T3 Code Desktop", "--json"]).pipe( + Effect.flatMap(decodeSession), + ), + (session) => + Effect.promise((signal) => + verifyLoopbackDiscoveryProof({ + token: session.token, + environmentId, + port: owner.port, + nonce, + fetchProof: fetch, + signal, + }), + ).pipe( + Effect.timeout("3 seconds"), + Effect.map((verified) => + verified + ? Option.some({ port: owner.port, token: session.token }) + : Option.none(), + ), + ), + ({ sessionId }, exit) => { + const revoke = sessionCommand(["revoke", sessionId]).pipe(Effect.ignore); + return Exit.isSuccess(exit) && Option.isSome(exit.value) + ? Scope.addFinalizer(desktopScope, revoke) + : revoke; + }, + ); + }, + Effect.orElseSucceed(() => Option.none()), +); + export const homeOwnedMessage = (owner: Option.Option): string => Option.match(owner, { onNone: () => diff --git a/apps/desktop/src/ipc/methods/serverExposure.ts b/apps/desktop/src/ipc/methods/serverExposure.ts index 9a9ce768973b3..d6a70969677f8 100644 --- a/apps/desktop/src/ipc/methods/serverExposure.ts +++ b/apps/desktop/src/ipc/methods/serverExposure.ts @@ -4,13 +4,30 @@ import { DesktopServerExposureStateSchema, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; +import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; import * as DesktopLifecycle from "../../app/DesktopLifecycle.ts"; +import * as DesktopBackendPool from "../../backend/DesktopBackendPool.ts"; import * as DesktopServerExposure from "../../backend/DesktopServerExposure.ts"; import * as IpcChannels from "../channels.ts"; import * as DesktopIpc from "../DesktopIpc.ts"; +class ExternalServerExposureError extends Schema.TaggedError()( + "ExternalServerExposureError", + {}, +) { + override get message() { + return "The running T3 server controls its network settings."; + } +} + +const requireDesktopOwnedServer = Effect.gen(function* () { + if (Option.isSome(yield* (yield* DesktopBackendPool.DesktopBackendPool).attachedHomeOwner)) { + return yield* new ExternalServerExposureError(); + } +}); + const SetTailscaleServeEnabledInput = Schema.Struct({ enabled: Schema.Boolean, port: Schema.optionalKey(Schema.Number), @@ -31,6 +48,7 @@ export const setServerExposureMode = DesktopIpc.makeIpcMethod({ payload: DesktopServerExposureModeSchema, result: DesktopServerExposureStateSchema, handler: Effect.fn("desktop.ipc.serverExposure.setMode")(function* (mode) { + yield* requireDesktopOwnedServer; const lifecycle = yield* DesktopLifecycle.DesktopLifecycle; const serverExposure = yield* DesktopServerExposure.DesktopServerExposure; const change = yield* serverExposure.setMode(mode); @@ -46,6 +64,7 @@ export const setTailscaleServeEnabled = DesktopIpc.makeIpcMethod({ payload: SetTailscaleServeEnabledInput, result: DesktopServerExposureStateSchema, handler: Effect.fn("desktop.ipc.serverExposure.setTailscaleServeEnabled")(function* (input) { + yield* requireDesktopOwnedServer; const lifecycle = yield* DesktopLifecycle.DesktopLifecycle; const serverExposure = yield* DesktopServerExposure.DesktopServerExposure; const change = yield* serverExposure.setTailscaleServeEnabled(input); diff --git a/apps/desktop/src/ipc/methods/window.test.ts b/apps/desktop/src/ipc/methods/window.test.ts index b256025eff844..4b374df793242 100644 --- a/apps/desktop/src/ipc/methods/window.test.ts +++ b/apps/desktop/src/ipc/methods/window.test.ts @@ -97,6 +97,34 @@ const bootstrapsLayer = (instances: ReadonlyArray { + it.effect("connects the primary renderer to the verified home owner after a port collision", () => + Effect.gen(function* () { + const primary = { + ...defaultWslInstance, + id: DesktopBackendManager.PRIMARY_INSTANCE_ID, + label: Effect.succeed("Local"), + }; + const result = yield* getLocalEnvironmentBootstraps.handler().pipe( + Effect.provide([ + Layer.mock(DesktopBackendPool.DesktopBackendPool, { + list: Effect.succeed([primary]), + attachedHomeOwner: Effect.succeedSome({ port: 3782, token: "private-session" }), + }), + backendConfigurationLayer, + ]), + ); + assert.deepEqual(result, [ + { + id: primary.id, + label: "Local", + runningDistro: null, + externallyManaged: true, + httpBaseUrl: "http://127.0.0.1:3782/", + wsBaseUrl: "ws://127.0.0.1:3782/", + }, + ]); + }), + ); it.effect("hands out the current window's token to a backend launched with the secret", () => Effect.gen(function* () { const result = yield* getLocalEnvironmentBootstraps.handler(); diff --git a/apps/desktop/src/ipc/methods/window.ts b/apps/desktop/src/ipc/methods/window.ts index 2545cb9dc5390..d0698883d8f6f 100644 --- a/apps/desktop/src/ipc/methods/window.ts +++ b/apps/desktop/src/ipc/methods/window.ts @@ -154,9 +154,22 @@ export const getLocalEnvironmentBootstraps = DesktopIpc.makeSyncIpcMethod({ const pool = yield* DesktopBackendPool.DesktopBackendPool; const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration; const instances = yield* pool.list; + const attached = yield* pool.attachedHomeOwner; const bootstraps: DesktopEnvironmentBootstrap[] = []; for (const instance of instances) { const isPrimary = instance.id === PRIMARY_LOCAL_ENVIRONMENT_ID; + if (isPrimary && Option.isSome(attached)) { + const httpBaseUrl = new URL(`http://127.0.0.1:${attached.value.port}/`); + bootstraps.push({ + id: instance.id, + label: yield* instance.label, + runningDistro: null, + externallyManaged: true, + httpBaseUrl: httpBaseUrl.href, + wsBaseUrl: toWebSocketBaseUrl(httpBaseUrl), + }); + continue; + } const config = yield* instance.currentConfig; const snapshot = yield* instance.snapshot; if (Option.isNone(config) || Option.isSome(config.value.preflightFailure)) { @@ -211,6 +224,8 @@ export const getLocalEnvironmentBearerToken = DesktopIpc.makeIpcMethod({ payload: Schema.Void, result: Schema.String, handler: Effect.fn("desktop.ipc.window.getLocalEnvironmentBearerToken")(function* () { + const attached = yield* (yield* DesktopBackendPool.DesktopBackendPool).attachedHomeOwner; + if (Option.isSome(attached)) return attached.value.token; const localAuth = yield* DesktopLocalEnvironmentAuth.DesktopLocalEnvironmentAuth; return yield* localAuth.getBearerToken; }), diff --git a/apps/desktop/src/wsl/DesktopWslBackend.test.ts b/apps/desktop/src/wsl/DesktopWslBackend.test.ts index d9ae6e76c29c2..77ef52d1009b6 100644 --- a/apps/desktop/src/wsl/DesktopWslBackend.test.ts +++ b/apps/desktop/src/wsl/DesktopWslBackend.test.ts @@ -115,6 +115,8 @@ describe("DesktopWslBackend", () => { }); return registeredWsl; }), + attachedHomeOwner: Effect.succeedNone, + connectToHomeOwner: Effect.die("unexpected home owner"), unregister: () => Effect.sync(() => { registeredWsl = undefined; diff --git a/apps/desktop/src/wsl/DesktopWslBackend.ts b/apps/desktop/src/wsl/DesktopWslBackend.ts index 2249c7764c698..9f3a7fa159bca 100644 --- a/apps/desktop/src/wsl/DesktopWslBackend.ts +++ b/apps/desktop/src/wsl/DesktopWslBackend.ts @@ -93,8 +93,11 @@ export const layer = Layer.effect( const startNew = Effect.fn("desktop.wslBackend.startNew")(function* (input: { readonly distro: string | null; }) { - const primaryConfig = yield* serverExposure.backendConfig; - const port = yield* scanForWslPort(primaryConfig.port + 1).pipe( + const attached = yield* pool.attachedHomeOwner; + const primaryPort = Option.isSome(attached) + ? attached.value.port + : (yield* serverExposure.backendConfig).port; + const port = yield* scanForWslPort(primaryPort + 1).pipe( Effect.provideService(NetService.NetService, net), Effect.asSome, Effect.catch((error) => diff --git a/apps/web/src/components/settings/ConnectionsSettings.logic.test.ts b/apps/web/src/components/settings/ConnectionsSettings.logic.test.ts index c06f06424842e..9173b363a5350 100644 --- a/apps/web/src/components/settings/ConnectionsSettings.logic.test.ts +++ b/apps/web/src/components/settings/ConnectionsSettings.logic.test.ts @@ -1,7 +1,12 @@ -import { type DesktopWslState, EnvironmentId } from "@t3tools/contracts"; +import { + type DesktopWslState, + EnvironmentId, + PRIMARY_LOCAL_ENVIRONMENT_ID, +} from "@t3tools/contracts"; import { describe, expect, it, vi } from "vite-plus/test"; import { applyWslEnableSelection, + hasExternallyManagedPrimary, isServerNetworkAccessible, parseManualDesktopSshTarget, resolveAccessEnvironmentId, @@ -238,3 +243,16 @@ describe("isServerNetworkAccessible", () => { expect(isServerNetworkAccessible(row)).toBe(row.expected); }); }); + +it("exposes desktop network controls only for the primary backend it started", () => { + const primary = { + id: PRIMARY_LOCAL_ENVIRONMENT_ID, + label: "Local", + httpBaseUrl: null, + wsBaseUrl: null, + }; + const wsl = { ...primary, id: "wsl:Ubuntu" }; + expect(hasExternallyManagedPrimary([{ ...wsl, externallyManaged: true }])).toBe(false); + expect(hasExternallyManagedPrimary([primary, wsl])).toBe(false); + expect(hasExternallyManagedPrimary([{ ...primary, externallyManaged: true }, wsl])).toBe(true); +}); diff --git a/apps/web/src/components/settings/ConnectionsSettings.logic.ts b/apps/web/src/components/settings/ConnectionsSettings.logic.ts index 724f7f22b0556..77a28f3efcf2e 100644 --- a/apps/web/src/components/settings/ConnectionsSettings.logic.ts +++ b/apps/web/src/components/settings/ConnectionsSettings.logic.ts @@ -16,6 +16,8 @@ import { AuthTerminalOperateScope, AuthTerminalReadScope, type DesktopBridge, + type DesktopEnvironmentBootstrap, + PRIMARY_LOCAL_ENVIRONMENT_ID, type DesktopServerExposureState, type DesktopSshEnvironmentTarget, type DesktopUpdateState, @@ -375,6 +377,14 @@ export function selectPairingEndpoint( ); } +export function hasExternallyManagedPrimary( + bootstraps: ReadonlyArray, +) { + return bootstraps.some( + (entry) => entry.id === PRIMARY_LOCAL_ENVIRONMENT_ID && entry.externallyManaged === true, + ); +} + /** A loopback server advertises a direct endpoint only once its Tailscale Serve URL answers. */ export function isServerNetworkAccessible(input: { readonly authPolicy: ServerAuthPolicy | null; diff --git a/apps/web/src/components/settings/ConnectionsSettings.tsx b/apps/web/src/components/settings/ConnectionsSettings.tsx index 1776f4f440f3a..29b89542e1366 100644 --- a/apps/web/src/components/settings/ConnectionsSettings.tsx +++ b/apps/web/src/components/settings/ConnectionsSettings.tsx @@ -126,6 +126,7 @@ import { toDesktopClientSessionRecord, selectPairingEndpoint, isServerNetworkAccessible, + hasExternallyManagedPrimary, isTailscaleHttpsEndpoint, endpointDefaultPreferenceKey, } from "./ConnectionsSettings.logic"; @@ -253,7 +254,12 @@ function ConnectionsSettingsContent({ readonly accessEnvironmentId: EnvironmentId | null; readonly accessEnvironmentPicker?: ReactNode; }) { - const desktopBridge = window.desktopBridge; + const [desktopBridge] = useState(() => { + const bridge = window.desktopBridge; + return bridge && !hasExternallyManagedPrimary(bridge.getLocalEnvironmentBootstraps()) + ? bridge + : undefined; + }); const { environments } = useEnvironments(); const primaryEnvironment = usePrimaryEnvironment(); const peerLinkHosts = usePeerLinkHosts(); @@ -1202,7 +1208,8 @@ function ConnectionsSettingsContent({ - {desktopBridge ? ( + {window.desktopBridge ? ( diff --git a/packages/client-runtime/src/connection/index.ts b/packages/client-runtime/src/connection/index.ts index 276ca9515a03d..6399be81100b5 100644 --- a/packages/client-runtime/src/connection/index.ts +++ b/packages/client-runtime/src/connection/index.ts @@ -1,5 +1,5 @@ export * from "./catalog.ts"; -export { makeLanDiscoveryVerifier } from "./lanDiscoveryProof.ts"; +export { makeLanDiscoveryVerifier, verifyLoopbackDiscoveryProof } from "./lanDiscoveryProof.ts"; export * from "./diagnosis.ts"; export * as Connectivity from "./connectivity.ts"; export * as CredentialStore from "./credentialStore.ts"; diff --git a/packages/client-runtime/src/connection/lanDiscoveryProof.test.ts b/packages/client-runtime/src/connection/lanDiscoveryProof.test.ts index c98ed82ffb249..f3038ecff571b 100644 --- a/packages/client-runtime/src/connection/lanDiscoveryProof.test.ts +++ b/packages/client-runtime/src/connection/lanDiscoveryProof.test.ts @@ -1,7 +1,7 @@ // @effect-diagnostics-next-line nodeBuiltinImport:off -- Compare against Node HMAC independently. import * as NodeCrypto from "node:crypto"; import { describe, expect, it } from "vite-plus/test"; -import { verifyLanDiscoveryProof } from "./lanDiscoveryProof.ts"; +import { verifyLanDiscoveryProof, verifyLoopbackDiscoveryProof } from "./lanDiscoveryProof.ts"; const signature = Buffer.alloc(32, 0x41).toString("base64url"); const token = `cGF5bG9hZA.${signature}`; @@ -89,3 +89,32 @@ describe("LAN discovery proof", () => { ).toBe(false); }); }); + +it("authenticates a local owner on its recorded port without admitting loopback through LAN discovery", async () => { + const calls: string[] = []; + const input = { + token, + nonce, + environmentId: "home", + port: 3773, + fetchProof: async (url: string, init: RequestInit) => { + calls.push(url); + expect(init.body).toBe(JSON.stringify({ payload: "cGF5bG9hZA", nonce })); + return Response.json({ proof: expectedProof("home", "127.0.0.1", 3773) }); + }, + }; + expect(await verifyLoopbackDiscoveryProof(input)).toBe(true); + expect(await verifyLoopbackDiscoveryProof({ ...input, environmentId: "other" })).toBe(false); + expect(await verifyLoopbackDiscoveryProof({ ...input, port: 3774 })).toBe(false); + for (const port of [0, 65536, 1.5]) { + expect(await verifyLoopbackDiscoveryProof({ ...input, port })).toBe(false); + } + expect(await verifyLanDiscoveryProof({ ...input, candidate: "http://127.0.0.1:3773/" })).toBe( + false, + ); + expect(calls).toEqual([ + "http://127.0.0.1:3773/api/lan-discovery/proof", + "http://127.0.0.1:3773/api/lan-discovery/proof", + "http://127.0.0.1:3774/api/lan-discovery/proof", + ]); +}); diff --git a/packages/client-runtime/src/connection/lanDiscoveryProof.ts b/packages/client-runtime/src/connection/lanDiscoveryProof.ts index f91d18e3e178e..cdb96ad5aa103 100644 --- a/packages/client-runtime/src/connection/lanDiscoveryProof.ts +++ b/packages/client-runtime/src/connection/lanDiscoveryProof.ts @@ -37,14 +37,33 @@ export function parseLanDiscoveryCandidate(candidate: string): URL | null { return url; } -export async function verifyLanDiscoveryProof(input: { +interface DiscoveryChallenge { readonly token: string; readonly nonce: string; readonly environmentId: string; - readonly candidate: string; readonly fetchProof: (url: string, init: RequestInit) => Promise; readonly signal?: AbortSignal; -}): Promise { +} + +export function verifyLanDiscoveryProof( + input: DiscoveryChallenge & { readonly candidate: string }, +) { + return verifyDiscoveryProof(input, parseLanDiscoveryCandidate(input.candidate)); +} + +export function verifyLoopbackDiscoveryProof( + input: DiscoveryChallenge & { readonly port: number }, +) { + const port = input.port; + const url = + Number.isInteger(port) && port > 0 && port <= 65535 + ? new URL(`http://127.0.0.1:${port}`) + : null; + return verifyDiscoveryProof(input, url); +} + +async function verifyDiscoveryProof(input: DiscoveryChallenge, url: URL | null): Promise { + if (url === null) return false; const parts = input.token.split("."); if ( parts.length !== 2 || @@ -55,8 +74,6 @@ export async function verifyLanDiscoveryProof(input: { return false; const key = Result.getOrUndefined(Base64Url.decode(parts[1]!)); if (key?.length !== 32) return false; - const url = parseLanDiscoveryCandidate(input.candidate); - if (url === null) return false; const address = url.hostname; const port = Number(url.port || 80); try { diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts index 30ea9047cece8..a39f34acae6d7 100644 --- a/packages/contracts/src/ipc.ts +++ b/packages/contracts/src/ipc.ts @@ -384,6 +384,7 @@ export interface DesktopEnvironmentBootstrap { httpBaseUrl: string | null; wsBaseUrl: string | null; bootstrapToken?: string; + externallyManaged?: true; } export const DesktopEnvironmentBootstrapSchema = Schema.Struct({ @@ -393,6 +394,7 @@ export const DesktopEnvironmentBootstrapSchema = Schema.Struct({ httpBaseUrl: Schema.NullOr(Schema.String), wsBaseUrl: Schema.NullOr(Schema.String), bootstrapToken: Schema.optionalKey(Schema.String), + externallyManaged: Schema.optionalKey(Schema.Literal(true)), }); export type DesktopSshHostSource = "ssh-config" | "known-hosts";