// @effect-diagnostics-next-line nodeBuiltinImport:off -- Effect's Crypto has no generateKeyPairSync or sign.
import * as NodeCrypto from "node:crypto";
import * as NodePlatformCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { authScopeResponse, AuthStandardClientScopes } from "@t3tools/contracts";
import {
computeDpopAccessTokenHash,
computeDpopJwkThumbprint,
type DpopPublicJwk,
} from "@t3tools/shared/dpop";
import { expect, it } from "@effect/vitest";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import * as ServerConfig from "../config.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as EnvironmentAuth from "./EnvironmentAuth.ts";
import * as ServerSecretStore from "./ServerSecretStore.ts";
import * as SessionStore from "./SessionStore.ts";
import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
const TEST_SERVER_PORT = 13_773;
const layerServerConfig = (overrides?: Partial<ServerConfig.ServerConfig["Service"]>) =>
Layer.effect(
ServerConfig.ServerConfig,
Effect.gen(function* () {
const config = yield* ServerConfig.ServerConfig;
return {
...config,
...overrides,
port: TEST_SERVER_PORT,
} satisfies ServerConfig.ServerConfig["Service"];
}),
).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-auth-server-test-" })));
const layerEnvironmentAuth = (overrides?: Partial<ServerConfig.ServerConfig["Service"]>) =>
EnvironmentAuth.layer.pipe(
Layer.provide(ManagedPolicy.layerTest()),
Layer.provideMerge(SqlitePersistence.layerMemory),
Layer.provide(ServerSecretStore.layer),
Layer.provide(ServerEnvironment.layerIdentity),
Layer.provide(layerServerConfig(overrides)),
);
const makeCookieRequest = (
cookieName: string,
sessionToken: string,
): Parameters<EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]>[0] =>
({
cookies: {
[cookieName]: sessionToken,
},
headers: {},
}) as unknown as Parameters<
EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]
>[0];
const makeBearerRequest = (
token: string,
): Parameters<EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]>[0] =>
({
cookies: {},
headers: {
authorization: `Bearer ${token}`,
},
}) as unknown as Parameters<
EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]
>[0];
const requestMetadata = {
deviceType: "desktop" as const,
os: "macOS",
browser: "Chrome",
ipAddress: "192.168.1.23",
};
const makeDpopKey = () => {
const { privateKey, publicKey } = NodeCrypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
const publicJwk = publicKey.export({ format: "jwk" }) as DpopPublicJwk;
let proofCount = 0;
return {
thumbprint: computeDpopJwkThumbprint(publicJwk),
sign: (input: {
readonly method: string;
readonly url: string;
readonly token: string;
readonly iat: number;
}) => {
const encode = (value: unknown) => Buffer.from(JSON.stringify(value)).toString("base64url");
const header = encode({ typ: "dpop+jwt", alg: "ES256", jwk: publicJwk });
const payload = encode({
htm: input.method,
htu: input.url,
jti: `proof-${++proofCount}`,
iat: input.iat,
ath: computeDpopAccessTokenHash(input.token),
});
const signature = NodeCrypto.sign("sha256", Buffer.from(`${header}.${payload}`), {
key: privateKey,
dsaEncoding: "ieee-p1363",
}).toString("base64url");
return `${header}.${payload}.${signature}`;
},
};
};
it.layer(Layer.mergeAll(NodeServices.layer, NodePlatformCrypto.layer))(
"EnvironmentAuth.layer",
(it) => {
it.effect("uses the reusable dev cookie without overriding a normal scoped cookie", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const token = "reusable-dev-auth-token-that-is-long-enough";
const devExchange = yield* serverAuth.createBrowserSession(token, requestMetadata);
const pairing = yield* serverAuth.issuePairingCredential({
scopes: ["orchestration:read"],
});
const scopedExchange = yield* serverAuth.createBrowserSession(
pairing.credential,
requestMetadata,
);
const request = {
cookies: {
[sessions.cookieName]: scopedExchange.sessionToken,
[devExchange.cookieName ?? "missing"]: devExchange.sessionToken,
},
headers: {},
} as unknown as Parameters<
EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]
>[0];
const authenticated = yield* serverAuth.authenticateHttpRequest(request);
expect(devExchange.cookieName).toMatch(/^t3_dev_session_/);
expect(devExchange.expireNormalCookie).toBe(true);
expect(devExchange.response).toMatchObject(authScopeResponse(AuthStandardClientScopes));
expect(authenticated.scopes).toEqual(["orchestration:read"]);
}).pipe(
Effect.provide(
layerEnvironmentAuth({
mode: "web",
devUrl: new URL("http://127.0.0.1:5173"),
devAuthToken: Redacted.make("reusable-dev-auth-token-that-is-long-enough"),
}),
),
),
);
it.effect("does not fall back to the dev cookie after a normal cookie is rejected", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const token = "reusable-dev-auth-token-that-is-long-enough";
const devExchange = yield* serverAuth.createBrowserSession(token, requestMetadata);
const pairing = yield* serverAuth.issuePairingCredential({
scopes: ["orchestration:read"],
});
const scopedExchange = yield* serverAuth.createBrowserSession(
pairing.credential,
requestMetadata,
);
const scoped = yield* sessions.verify(scopedExchange.sessionToken);
yield* sessions.revoke(scoped.sessionId);
const request = {
cookies: {
[sessions.cookieName]: scopedExchange.sessionToken,
[devExchange.cookieName ?? "missing"]: devExchange.sessionToken,
},
headers: {},
} as unknown as Parameters<
EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]
>[0];
const error = yield* Effect.flip(serverAuth.authenticateHttpRequest(request));
expect(error._tag).toBe("ServerAuthInvalidCredentialError");
}).pipe(
Effect.provide(
layerEnvironmentAuth({
mode: "web",
devUrl: new URL("http://127.0.0.1:5173"),
devAuthToken: Redacted.make("reusable-dev-auth-token-that-is-long-enough"),
}),
),
),
);
it.effect("does not use the dev cookie when Authorization is invalid or empty", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const token = "reusable-dev-auth-token-that-is-long-enough";
const devExchange = yield* serverAuth.createBrowserSession(token, requestMetadata);
for (const authorization of [
"Bearer invalid",
"bearer invalid",
"bEaReR invalid",
"Basic invalid",
"",
] as const) {
const request = {
cookies: { [devExchange.cookieName ?? "missing"]: devExchange.sessionToken },
headers: { authorization },
} as unknown as Parameters<
EnvironmentAuth.EnvironmentAuth["Service"]["authenticateHttpRequest"]
>[0];
const error = yield* Effect.flip(serverAuth.authenticateHttpRequest(request));
expect(EnvironmentAuth.isServerAuthCredentialError(error)).toBe(true);
}
}).pipe(
Effect.provide(
layerEnvironmentAuth({
mode: "web",
devUrl: new URL("http://127.0.0.1:5173"),
devAuthToken: Redacted.make("reusable-dev-auth-token-that-is-long-enough"),
}),
),
),
);
it.effect("exchanges the reusable dev token for a local scoped OAuth session", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const token = "reusable-dev-auth-token-that-is-long-enough";
const exchanged = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
token,
["orchestration:read"],
requestMetadata,
);
expect(exchanged.access_token).not.toBe(token);
expect(exchanged.scope).toBe("orchestration:read");
const dpop = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
token,
["orchestration:read"],
requestMetadata,
{ proofKeyThumbprint: "test-proof-key" },
);
expect(dpop.access_token).not.toBe(token);
expect(dpop.access_token).not.toBe(exchanged.access_token);
expect(dpop.token_type).toBe("DPoP");
expect(dpop.scope).toBe("orchestration:read");
const secondBearer = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
token,
["orchestration:read"],
requestMetadata,
);
const firstSession = yield* serverAuth.authenticateHttpRequest(
makeBearerRequest(exchanged.access_token),
);
const secondSession = yield* serverAuth.authenticateHttpRequest(
makeBearerRequest(secondBearer.access_token),
);
expect(firstSession.subject).toBe("reusable-dev-token-child");
expect(secondSession.subject).toBe("reusable-dev-token-child");
expect((yield* sessions.verify(token)).subject).toBe("reusable-dev-token");
const before = yield* serverAuth.listClientSessions(firstSession.sessionId);
const denied = yield* serverAuth
.exchangeBootstrapCredentialForAccessToken(token, ["review:write"], requestMetadata)
.pipe(Effect.flip);
expect(denied._tag).toBe("ServerAuthScopeNotGrantedError");
const empty = yield* serverAuth
.exchangeBootstrapCredentialForAccessToken(token, [], requestMetadata)
.pipe(Effect.flip);
expect(empty._tag).toBe("ServerAuthScopeNotGrantedError");
expect(yield* serverAuth.listClientSessions(firstSession.sessionId)).toEqual(before);
}).pipe(
Effect.provide(
layerEnvironmentAuth({
mode: "web",
devUrl: new URL("http://127.0.0.1:5173"),
devAuthToken: Redacted.make("reusable-dev-auth-token-that-is-long-enough"),
}),
),
),
);
it.effect("uses a one-time startup credential after local dev token revocation", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const token = "reusable-dev-auth-token-that-is-long-enough";
const initial = yield* serverAuth.issueStartupPairingCredential();
const seeded = yield* sessions.verify(token);
yield* sessions.revoke(seeded.sessionId);
const recovery = yield* serverAuth.issueStartupPairingCredential();
expect(initial.credential).toBe(token);
expect(recovery.credential).not.toBe(token);
expect((yield* Effect.flip(sessions.verify(token)))._tag).toBe("SessionTokenRevokedError");
expect(
(yield* serverAuth.createBrowserSession(recovery.credential, requestMetadata)).response,
).toMatchObject({ authenticated: true, ...authScopeResponse(AuthStandardClientScopes) });
}).pipe(
Effect.provide(
layerEnvironmentAuth({
mode: "web",
devUrl: new URL("http://127.0.0.1:5173"),
devAuthToken: Redacted.make("reusable-dev-auth-token-that-is-long-enough"),
}),
),
),
);
it.effect("prefers a bearer token over a stale legacy cookie", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const bearer = yield* serverAuth.issueSession();
const verified = yield* serverAuth.authenticateHttpRequest({
cookies: { [sessions.legacyCookieName ?? "t3_session"]: "stale" },
headers: { authorization: `Bearer ${bearer.token}` },
} as never);
expect(verified.sessionId).toBe(bearer.sessionId);
}).pipe(Effect.provide(layerEnvironmentAuth({ mode: "web", host: "192.168.1.50" }))),
);
it.effect("prefers a bearer token over an empty primary cookie", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const bearer = yield* serverAuth.issueSession();
const verified = yield* serverAuth.authenticateHttpRequest({
cookies: { [sessions.cookieName]: "" },
headers: { authorization: `Bearer ${bearer.token}` },
} as never);
expect(verified.sessionId).toBe(bearer.sessionId);
}).pipe(Effect.provide(layerEnvironmentAuth({ mode: "web", host: "192.168.1.50" }))),
);
it.effect("preserves pairing grants after rejecting scopes they do not grant", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const pairingCredential = yield* serverAuth.issuePairingCredential({
scopes: ["orchestration:read", "orchestration:operate"],
});
const error = yield* serverAuth
.exchangeBootstrapCredentialForAccessToken(
pairingCredential.credential,
["access:write"],
requestMetadata,
)
.pipe(Effect.flip);
expect(error._tag).toBe("ServerAuthScopeNotGrantedError");
expect((yield* serverAuth.listPairingLinks()).map((link) => link.id)).toContain(
pairingCredential.id,
);
expect(yield* serverAuth.listSessions()).toEqual([]);
const token = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
pairingCredential.credential,
["orchestration:read"],
requestMetadata,
);
const session = yield* serverAuth.authenticateHttpRequest(
makeBearerRequest(token.access_token),
);
expect(token.scope).toBe("orchestration:read");
expect(session.scopes).toEqual(["orchestration:read"]);
expect((yield* serverAuth.listPairingLinks()).map((link) => link.id)).not.toContain(
pairingCredential.id,
);
const reused = yield* serverAuth
.exchangeBootstrapCredentialForAccessToken(
pairingCredential.credential,
["orchestration:read"],
requestMetadata,
)
.pipe(Effect.flip);
expect(reused._tag).toBe("ServerAuthInvalidCredentialError");
}).pipe(Effect.provide(layerEnvironmentAuth())),
);
it.effect.each([
{ label: "omits scope", requestedScopes: undefined },
{
label: "requests unsupported permissions alongside a granted one",
requestedScopes: ["orchestration:read", "access:write"] as const,
},
])("inherits a constrained pairing grant when token exchange $label", ({ requestedScopes }) =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const pairingCredential = yield* serverAuth.issuePairingCredential({
scopes: ["orchestration:read"],
});
const token = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
pairingCredential.credential,
requestedScopes,
requestMetadata,
);
expect(token.scope).toBe("orchestration:read");
}).pipe(Effect.provide(layerEnvironmentAuth())),
);
it.effect(
"preserves a rejected MCP pairing code for exactly one concurrent lower-access retry",
() =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const pairing = yield* serverAuth.issuePairingCredential({
scopes: ["orchestration:read"],
});
const rejected = yield* Effect.flip(
serverAuth.consumeMcpApprovalCode(pairing.credential, "full-access"),
);
expect(rejected).toMatchObject({
_tag: "ServerAuthMcpApprovalCodeError",
reason: "insufficient_scope",
});
const retry = Effect.result(
serverAuth.consumeMcpApprovalCode(pairing.credential, "read-only"),
);
const results = yield* Effect.all([retry, retry], { concurrency: "unbounded" });
expect(results.filter((result) => result._tag === "Success")).toHaveLength(1);
expect(results.filter((result) => result._tag === "Failure")).toMatchObject([
{ failure: { _tag: "ServerAuthMcpApprovalCodeError", reason: "unknown_or_used" } },
]);
}).pipe(Effect.provide(layerEnvironmentAuth())),
);
it.effect("narrows seeded desktop grants to the requested scopes", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const token = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
"desktop-bootstrap-token",
["orchestration:read"],
requestMetadata,
);
const session = yield* serverAuth.authenticateHttpRequest(
makeBearerRequest(token.access_token),
);
expect(token.scope).toBe("orchestration:read");
expect(session.scopes).toEqual(["orchestration:read"]);
}).pipe(
Effect.provide(layerEnvironmentAuth({ desktopBootstrapToken: "desktop-bootstrap-token" })),
),
);
it.effect("rotates desktop bearer sessions without accumulating authorized clients", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const browser = yield* serverAuth.createBrowserSession(
"desktop-bootstrap-token",
requestMetadata,
);
const browserSession = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, browser.sessionToken),
);
const staleSessions = yield* Effect.forEach([1, 2, 3], () =>
sessions.issue({ subject: "desktop-bootstrap", method: "bearer-access-token" }),
);
const pairing = yield* serverAuth.issuePairingCredential();
const paired = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
pairing.credential,
undefined,
{ ...requestMetadata, label: "T3 Code Desktop" },
);
const first = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
"desktop-bootstrap-token",
undefined,
requestMetadata,
);
const firstSession = yield* serverAuth.authenticateHttpRequest(
makeBearerRequest(first.access_token),
);
const second = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
"desktop-bootstrap-token",
undefined,
requestMetadata,
);
const active = yield* serverAuth.listSessions();
const firstError = yield* serverAuth
.authenticateHttpRequest(makeBearerRequest(first.access_token))
.pipe(Effect.flip);
const secondSession = yield* serverAuth.authenticateHttpRequest(
makeBearerRequest(second.access_token),
);
expect(active).toHaveLength(3);
expect(active.map((entry) => entry.sessionId)).toContain(browserSession.sessionId);
expect(active.map((entry) => entry.sessionId)).toContain(secondSession.sessionId);
expect(active.map((entry) => entry.sessionId)).not.toContain(firstSession.sessionId);
expect(firstError._tag).toBe("ServerAuthInvalidCredentialError");
for (const stale of staleSessions) {
const error = yield* sessions.verify(stale.token).pipe(Effect.flip);
expect(error._tag).toBe("SessionTokenRevokedError");
}
const pairedSession = yield* serverAuth.authenticateHttpRequest(
makeBearerRequest(paired.access_token),
);
expect(pairedSession.subject).toBe("one-time-token");
expect(active.map((entry) => entry.sessionId)).toContain(pairedSession.sessionId);
}).pipe(
Effect.provide(
layerEnvironmentAuth({
desktopBootstrapToken: "desktop-bootstrap-token",
}),
),
),
);
it.effect("issues startup pairing URLs that bootstrap administrative sessions", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const pairingUrl = yield* serverAuth.issueStartupPairingUrl("http://127.0.0.1:3773");
const token = new URLSearchParams(new URL(pairingUrl).hash.slice(1)).get("token");
const listedPairingLinks = yield* serverAuth.listPairingLinks();
expect(token).toBeTruthy();
expect(
listedPairingLinks.some(
(pairingLink) => pairingLink.subject === "administrative-bootstrap",
),
).toBe(false);
const exchanged = yield* serverAuth.createBrowserSession(token ?? "", requestMetadata);
const verified = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, exchanged.sessionToken),
);
expect(verified.scopes).toEqual(AuthStandardClientScopes);
expect(verified.subject).toBe("administrative-bootstrap");
}).pipe(Effect.provide(layerEnvironmentAuth())),
);
it.effect(
"lists pairing links and revokes other sessions while keeping the administrative session",
() =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const administrativeExchange = yield* serverAuth.createBrowserSession(
"desktop-bootstrap-token",
requestMetadata,
);
const administrativeSession = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, administrativeExchange.sessionToken),
);
const pairingCredential = yield* serverAuth.issuePairingCredential({
label: "Julius iPhone",
});
const listedPairingLinks = yield* serverAuth.listPairingLinks();
const clientExchange = yield* serverAuth.createBrowserSession(
pairingCredential.credential,
{
...requestMetadata,
deviceType: "mobile",
os: "iOS",
browser: "Safari",
ipAddress: "192.168.1.88",
},
);
const clientSession = yield* serverAuth.authenticateHttpRequest(
makeCookieRequest(sessions.cookieName, clientExchange.sessionToken),
);
const clientsBeforeRevoke = yield* serverAuth.listClientSessions(
administrativeSession.sessionId,
);
const revokedCount = yield* serverAuth.revokeOtherClientSessions(
administrativeSession.sessionId,
);
const clientsAfterRevoke = yield* serverAuth.listClientSessions(
administrativeSession.sessionId,
);
expect(listedPairingLinks.map((entry) => entry.id)).toContain(pairingCredential.id);
expect(listedPairingLinks.find((entry) => entry.id === pairingCredential.id)?.label).toBe(
"Julius iPhone",
);
expect(clientsBeforeRevoke).toHaveLength(2);
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === administrativeSession.sessionId)
?.current,
).toBe(true);
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === clientSession.sessionId)
?.current,
).toBe(false);
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === clientSession.sessionId)?.client
.label,
).toBe("Julius iPhone");
expect(
clientsBeforeRevoke.find((entry) => entry.sessionId === clientSession.sessionId)?.client
.deviceType,
).toBe("mobile");
expect(revokedCount).toBe(1);
expect(clientsAfterRevoke).toHaveLength(1);
expect(clientsAfterRevoke[0]?.sessionId).toBe(administrativeSession.sessionId);
}).pipe(
Effect.provide(
layerEnvironmentAuth({
desktopBootstrapToken: "desktop-bootstrap-token",
}),
),
),
);
it.effect("accepts cookie sessions on socket upgrades only from the app's own origins", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const pairing = yield* serverAuth.issuePairingCredential();
const exchanged = yield* serverAuth.createBrowserSession(
pairing.credential,
requestMetadata,
);
const upgrade = (headers: Record<string, string>) =>
serverAuth.authenticateWebSocketUpgrade(
{
url: "/ws",
cookies: { [sessions.cookieName]: exchanged.sessionToken },
headers: { host: "192.168.1.50:3773", ...headers },
} as never,
"rpc",
);
yield* upgrade({ origin: "http://192.168.1.50:3773" });
yield* upgrade({
origin: "https://box.tail1234.ts.net",
"x-forwarded-host": "box.tail1234.ts.net",
});
yield* upgrade({ origin: "t3code://app" });
yield* upgrade({ origin: "http://localhost:5733" });
yield* upgrade({});
const otherPort = yield* Effect.flip(upgrade({ origin: "http://192.168.1.50:8080" }));
expect(otherPort._tag).toBe("ServerAuthInvalidCredentialError");
const opaque = yield* Effect.flip(upgrade({ origin: "null" }));
expect(opaque._tag).toBe("ServerAuthInvalidCredentialError");
}).pipe(
Effect.provide(
layerEnvironmentAuth({
mode: "web",
host: "192.168.1.50",
devUrl: new URL("http://localhost:5733"),
}),
),
),
);
it.effect("accepts cookie sessions on HTTP requests only from the app's own origins", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const pairing = yield* serverAuth.issuePairingCredential();
const exchanged = yield* serverAuth.createBrowserSession(
pairing.credential,
requestMetadata,
);
const post = (headers: Record<string, string>) =>
serverAuth.authenticateHttpRequest({
cookies: { [sessions.cookieName]: exchanged.sessionToken },
headers: { host: "localhost:13773", ...headers },
} as never);
yield* post({ origin: "http://192.168.1.50:5733", "sec-fetch-site": "same-origin" });
yield* post({ origin: "http://localhost:13773" });
const otherPort = yield* Effect.flip(
post({ origin: "http://localhost:3000", "sec-fetch-site": "same-site" }),
);
expect(otherPort._tag).toBe("ServerAuthInvalidCredentialError");
const state = yield* serverAuth.getSessionState({
cookies: { [sessions.cookieName]: exchanged.sessionToken },
headers: { host: "localhost:13773", origin: "http://localhost:3000" },
} as never);
expect(state.authenticated).toBe(false);
}).pipe(Effect.provide(layerEnvironmentAuth({ mode: "web" }))),
);
it.effect.each(["Bearer", "bearer", "bEaReR"])(
"accepts %s for HTTP and socket upgrades regardless of page origin",
(scheme) =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const bearer = yield* serverAuth.issueSession();
const request = {
url: "/ws",
cookies: {},
headers: {
host: "192.168.1.50:3773",
origin: "http://192.168.1.50:8080",
authorization: `${scheme} ${bearer.token}`,
},
} as never;
const verified = yield* serverAuth.authenticateWebSocketUpgrade(request, "rpc");
expect(verified.sessionId).toBe(bearer.sessionId);
expect((yield* serverAuth.authenticateHttpRequest(request)).sessionId).toBe(
bearer.sessionId,
);
}).pipe(Effect.provide(layerEnvironmentAuth({ mode: "web", host: "192.168.1.50" }))),
);
it.effect("binds a DPoP session's RPC socket ticket to its proof key", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const key = makeDpopKey();
const other = makeDpopKey();
const exchanged = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
"desktop-bootstrap-token",
["orchestration:read"],
requestMetadata,
{ proofKeyThumbprint: key.thumbprint },
);
const session = yield* sessions.verify(exchanged.access_token);
const host = "192.168.1.50:3773";
const socketUrl = `http://${host}/ws`;
const iat = Math.floor((yield* DateTime.now).epochMilliseconds / 1_000);
const upgrade = (ticket: string, use: "rpc" | "media", proof?: string) =>
serverAuth.authenticateWebSocketUpgrade(
{
method: "GET",
url: `/ws?orchestrationProtocol=2&wsTicket=${ticket}${proof ? `&dpop=${proof}` : ""}`,
cookies: {},
headers: { host },
} as never,
use,
);
const rpc = yield* serverAuth.issueWebSocketTicket(session, { use: "rpc" });
const bare = yield* Effect.flip(upgrade(Redacted.value(rpc.ticket), "rpc"));
expect(bare._tag).toBe("ServerAuthInvalidCredentialError");
const signed = yield* upgrade(
Redacted.value(rpc.ticket),
"rpc",
key.sign({ method: "GET", url: socketUrl, token: Redacted.value(rpc.ticket), iat }),
);
expect(signed.sessionId).toBe(session.sessionId);
const wrongKey = yield* Effect.flip(
upgrade(
Redacted.value(rpc.ticket),
"rpc",
other.sign({ method: "GET", url: socketUrl, token: Redacted.value(rpc.ticket), iat }),
),
);
expect(wrongKey._tag).toBe("ServerAuthInvalidCredentialError");
const onMedia = yield* Effect.flip(
upgrade(
Redacted.value(rpc.ticket),
"media",
key.sign({ method: "GET", url: socketUrl, token: Redacted.value(rpc.ticket), iat }),
),
);
expect(onMedia._tag).toBe("ServerAuthInvalidCredentialError");
const media = yield* serverAuth.issueWebSocketTicket(session, { use: "media" });
expect((yield* upgrade(Redacted.value(media.ticket), "media")).sessionId).toBe(
session.sessionId,
);
const mediaOnRpc = yield* Effect.flip(upgrade(Redacted.value(media.ticket), "rpc"));
expect(mediaOnRpc._tag).toBe("ServerAuthInvalidCredentialError");
// Clients that predate ticket binding still connect with the unbound ticket they mint.
const legacy = yield* serverAuth.issueWebSocketTicket(session);
expect((yield* upgrade(Redacted.value(legacy.ticket), "rpc")).sessionId).toBe(
session.sessionId,
);
}).pipe(
Effect.provide(layerEnvironmentAuth({ desktopBootstrapToken: "desktop-bootstrap-token" })),
),
);
it.effect.each(["DPoP", "dpop", "dPoP"])(
"accepts %s for a proof-bound HTTP request",
(scheme) =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const key = makeDpopKey();
const { access_token: token } =
yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
"desktop-bootstrap-token",
["orchestration:read"],
requestMetadata,
{ proofKeyThumbprint: key.thumbprint },
);
const iat = Math.floor((yield* DateTime.now).epochMilliseconds / 1_000);
const request = {
method: "GET",
url: "/api/auth/session",
cookies: {},
headers: {
host: "192.168.1.50:3773",
authorization: `${scheme} ${token}`,
dpop: key.sign({
method: "GET",
url: "http://192.168.1.50:3773/api/auth/session",
token,
iat,
}),
},
} as never;
expect((yield* serverAuth.authenticateHttpRequest(request)).sessionId).toBeTypeOf(
"string",
);
}).pipe(
Effect.provide(
layerEnvironmentAuth({ desktopBootstrapToken: "desktop-bootstrap-token" }),
),
),
);
it.effect("rejects a replayed proof on a bound RPC socket ticket", () =>
Effect.gen(function* () {
const serverAuth = yield* EnvironmentAuth.EnvironmentAuth;
const sessions = yield* SessionStore.SessionStore;
const key = makeDpopKey();
const exchanged = yield* serverAuth.exchangeBootstrapCredentialForAccessToken(
"desktop-bootstrap-token",
["orchestration:read"],
requestMetadata,
{ proofKeyThumbprint: key.thumbprint },
);
const session = yield* sessions.verify(exchanged.access_token);
const rpc = yield* serverAuth.issueWebSocketTicket(session, { use: "rpc" });
const request = {
method: "GET",
url: `/ws?wsTicket=${Redacted.value(rpc.ticket)}&dpop=${key.sign({
method: "GET",
url: "http://192.168.1.50:3773/ws",
token: Redacted.value(rpc.ticket),
iat: Math.floor((yield* DateTime.now).epochMilliseconds / 1_000),
})}`,
cookies: {},
headers: { host: "192.168.1.50:3773" },
} as never;
yield* serverAuth.authenticateWebSocketUpgrade(request, "rpc");
const replayed = yield* Effect.flip(
serverAuth.authenticateWebSocketUpgrade(request, "rpc"),
);
expect(replayed._tag).toBe("ServerAuthInvalidCredentialError");
if (replayed._tag === "ServerAuthInvalidCredentialError") {
expect(replayed.dpopFailureReason).toBe("replay");
}
}).pipe(
Effect.provide(layerEnvironmentAuth({ desktopBootstrapToken: "desktop-bootstrap-token" })),
),
);
},
);