Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
fix(calendar): fail OAuth loopback immediately on state mismatch (#1753)
Henry Su8b77a599ce91
diff --git a/src/helpers/oauthLoopbackFlow.js b/src/helpers/oauthLoopbackFlow.jsindex e8bbeb1cf..abad38e28 100644--- a/src/helpers/oauthLoopbackFlow.js+++ b/src/helpers/oauthLoopbackFlow.js@@ -57,8 +57,17 @@ function runOAuthLoopbackFlow({ buildAuthUrl, handleCallback, errorParam }) {const codeVerifier = crypto.randomBytes(32).toString("base64url").slice(0, 43);const codeChallenge = crypto.createHash("sha256").update(codeVerifier).digest("base64url");const state = crypto.randomBytes(32).toString("hex");+ let callbackClaimed = false;const server = http.createServer(async (req, res) => {+ // Accepted requests can outlive server.close(), so only the first+ // terminal callback may settle the flow or exchange a code.+ if (callbackClaimed) {+ res.writeHead(400, { "Content-Type": "text/html" });+ res.end("<html><body><h3>Invalid request.</h3></body></html>");+ return;+ }+try {const url = new URL(req.url, `http://127.0.0.1`);const returnedState = url.searchParams.get("state");@@ -66,6 +75,7 @@ function runOAuthLoopbackFlow({ buildAuthUrl, handleCallback, errorParam }) {const error = url.searchParams.get("error");if (error) {+ callbackClaimed = true;redirect(res, { [errorParam]: error });cleanup();reject(new Error(`OAuth error: ${error}`));@@ -75,9 +85,18 @@ function runOAuthLoopbackFlow({ buildAuthUrl, handleCallback, errorParam }) {if (!code || returnedState !== state) {res.writeHead(400, { "Content-Type": "text/html" });res.end("<html><body><h3>Invalid request.</h3></body></html>");+ // A real callback with a code but the wrong state is a failed+ // attempt (stale tab, CSRF). Fail the flow now. A request with no+ // code (favicon / bare GET) must keep waiting for the redirect.+ if (code) {+ callbackClaimed = true;+ cleanup();+ reject(new Error("OAuth state mismatch"));+ }return;}+ callbackClaimed = true;const redirectUri = `http://127.0.0.1:${server.address().port}`;const result = await handleCallback(code, redirectUri, codeVerifier);@@ -85,6 +104,7 @@ function runOAuthLoopbackFlow({ buildAuthUrl, handleCallback, errorParam }) {cleanup();resolve(result);} catch (err) {+ callbackClaimed = true;redirect(res, { [errorParam]: err.redirectCode || "server_error" });cleanup();reject(err);@@ -105,6 +125,7 @@ function runOAuthLoopbackFlow({ buildAuthUrl, handleCallback, errorParam }) {});timeoutId = setTimeout(() => {+ callbackClaimed = true;server.close();reject(new Error("OAuth flow timed out"));}, OAUTH_TIMEOUT_MS);diff --git a/test/helpers/oauthLoopbackFlow.test.js b/test/helpers/oauthLoopbackFlow.test.jsnew file mode 100644index 000000000..5885f6f77--- /dev/null+++ b/test/helpers/oauthLoopbackFlow.test.js@@ -0,0 +1,413 @@+const test = require("node:test");+const assert = require("node:assert/strict");+const http = require("node:http");+const net = require("node:net");+const Module = require("node:module");++const loopbackModulePath = require.resolve("../../src/helpers/oauthLoopbackFlow.js");+const originalLoad = Module._load;++function loadLoopback() {+ delete require.cache[loopbackModulePath];+ Module._load = function loadWithElectronMock(request, parent, isMain) {+ if (request === "electron") {+ return { shell: { openExternal() {} } };+ }+ return originalLoad.call(this, request, parent, isMain);+ };+ try {+ return require(loopbackModulePath);+ } finally {+ Module._load = originalLoad;+ }+}++function startFlow(handleCallback = async () => ({ ok: true })) {+ const { runOAuthLoopbackFlow } = loadLoopback();+ let redirectUri;+ let state;+ let server;+ const originalCreateServer = http.createServer;+ http.createServer = (...args) => {+ server = originalCreateServer(...args);+ return server;+ };++ try {+ const flow = runOAuthLoopbackFlow({+ errorParam: "gcal_error",+ buildAuthUrl: (uri, flowState) => {+ redirectUri = uri;+ state = flowState;+ return "https://example.test/auth";+ },+ handleCallback,+ });+ return { flow, server, getRedirectUri: () => redirectUri, getState: () => state };+ } finally {+ http.createServer = originalCreateServer;+ }+}++function startBlockedFlow() {+ let callbackCount = 0;+ let releaseHandleCallback;+ let markCallbackStarted;+ const callbackStarted = new Promise((resolve) => {+ markCallbackStarted = resolve;+ });+ const startedFlow = startFlow(async (code) => {+ callbackCount += 1;+ if (callbackCount === 1) {+ markCallbackStarted();+ await new Promise((resolve) => {+ releaseHandleCallback = resolve;+ });+ }+ return { code };+ });++ return {+ ...startedFlow,+ callbackStarted,+ getCallbackCount: () => callbackCount,+ releaseHandleCallback: () => releaseHandleCallback?.(),+ };+}++function startFlowWithControlledTimeout(handleCallback) {+ const originalSetTimeout = global.setTimeout;+ let runFlowTimeout;++ global.setTimeout = (callback, delay, ...args) => {+ if (delay === 120000) {+ runFlowTimeout = () => callback(...args);+ return originalSetTimeout(() => {}, 0);+ }+ return originalSetTimeout(callback, delay, ...args);+ };++ try {+ const startedFlow = startFlow(handleCallback);+ return {+ ...startedFlow,+ triggerTimeout: () => {+ if (!runFlowTimeout) throw new Error("OAuth timeout was not scheduled");+ runFlowTimeout();+ },+ };+ } finally {+ global.setTimeout = originalSetTimeout;+ }+}++async function waitForListen(getRedirectUri) {+ for (let i = 0; i < 50; i++) {+ if (getRedirectUri()) return getRedirectUri();+ await new Promise((resolve) => setTimeout(resolve, 10));+ }+ throw new Error("loopback server did not start");+}++function requestPath(redirectUri, path) {+ const { hostname, port } = new URL(redirectUri);+ return new Promise((resolve, reject) => {+ const request = http.get(+ { hostname, port, path, agent: false, headers: { Connection: "close" } },+ (response) => {+ response.resume();+ response.on("end", () => resolve(response.statusCode));+ }+ );+ request.on("error", reject);+ });+}++async function parkPartialRequest(redirectUri, server) {+ const { hostname, port } = new URL(redirectUri);+ let response = "";+ let responseStatus;+ let responseSettled = false;+ let resolveStatus;+ let rejectStatus;+ const status = new Promise((resolve, reject) => {+ resolveStatus = resolve;+ rejectStatus = reject;+ });+ const requestStarted = new Promise((resolve) => {+ server.once("connection", (acceptedSocket) => {+ acceptedSocket.once("data", resolve);+ });+ });+ const socket = net.createConnection({ host: hostname, port });+ socket.setEncoding("utf8");+ socket.on("data", (chunk) => {+ response += chunk;+ const match = /^HTTP\/1\.1 (\d{3})/.exec(response);+ if (match) {+ responseStatus = Number(match[1]);+ }+ });+ socket.on("end", () => {+ if (responseStatus && !responseSettled) {+ responseSettled = true;+ resolveStatus(responseStatus);+ }+ });+ socket.on("error", (error) => {+ if (!responseSettled) {+ responseSettled = true;+ rejectStatus(error);+ }+ });+ socket.on("close", () => {+ if (!responseSettled) {+ responseSettled = true;+ rejectStatus(new Error("parked request closed without a response"));+ }+ });++ await new Promise((resolve, reject) => {+ const handleConnect = () => {+ socket.off("error", handleError);+ resolve();+ };+ const handleError = (error) => {+ socket.off("connect", handleConnect);+ reject(error);+ };+ socket.once("connect", handleConnect);+ socket.once("error", handleError);+ });+ socket.write("GET /");+ await requestStarted;++ return {+ complete: (path) => {+ socket.end(+ `${path} HTTP/1.1\r\nHost: ${hostname}:${port}\r\nConnection: close\r\n\r\n`+ );+ return status;+ },+ destroy: () => socket.destroy(),+ };+}++test("a callback with a code and the wrong state rejects immediately", async () => {+ const { flow, getRedirectUri } = startFlow();+ const redirectUri = await waitForListen(getRedirectUri);+ const started = Date.now();+ const rejected = assert.rejects(flow, /OAuth state mismatch/);++ const response = await fetch(`${redirectUri}/?code=stolen&state=wrong`, {+ redirect: "manual",+ });+ assert.equal(response.status, 400);++ await rejected;+ assert.ok(Date.now() - started < 5000, "must not wait for the 120s timeout");+});++test("a request with no code leaves the flow running until a real callback", async () => {+ const { flow, getRedirectUri, getState } = startFlow(async (code) => ({ code }));+ const redirectUri = await waitForListen(getRedirectUri);++ const stray = await fetch(`${redirectUri}/favicon.ico`, { redirect: "manual" });+ assert.equal(stray.status, 400);++ const stillPending = await Promise.race([+ flow.then(+ () => "resolved",+ () => "rejected"+ ),+ new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),+ ]);+ assert.equal(stillPending, "pending");++ const success = await fetch(`${redirectUri}/?code=ok&state=${getState()}`, {+ redirect: "manual",+ });+ assert.equal(success.status, 302);+ assert.deepEqual(await flow, { code: "ok" });+});++test("a provider error query still fails the flow immediately", async () => {+ const { flow, getRedirectUri } = startFlow();+ const redirectUri = await waitForListen(getRedirectUri);+ const rejected = assert.rejects(flow, /OAuth error: access_denied/);++ const response = await fetch(`${redirectUri}/?error=access_denied`, {+ redirect: "manual",+ });+ assert.equal(response.status, 302);+ await rejected;+});++test("a late state mismatch cannot reject a valid callback already in progress", async () => {+ const {+ flow,+ getRedirectUri,+ getState,+ callbackStarted,+ releaseHandleCallback,+ } = startBlockedFlow();+ const redirectUri = await waitForListen(getRedirectUri);+ const flowOutcome = flow.then(+ () => "resolved",+ (error) => `rejected: ${error.message}`+ );++ const validResponsePromise = fetch(`${redirectUri}/?code=ok&state=${getState()}`, {+ redirect: "manual",+ });+ await callbackStarted;++ let mismatchResponse;+ let outcomeBeforeRelease;+ try {+ mismatchResponse = await fetch(`${redirectUri}/?code=stale&state=wrong`, {+ redirect: "manual",+ });+ outcomeBeforeRelease = await Promise.race([+ flowOutcome,+ new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),+ ]);+ } finally {+ releaseHandleCallback();+ }++ const validResponse = await validResponsePromise;+ assert.equal(mismatchResponse.status, 400);+ assert.equal(outcomeBeforeRelease, "pending");+ assert.equal(validResponse.status, 302);+ assert.equal(await flowOutcome, "resolved");+});++test("a late malformed request cannot reject a valid callback already in progress", async () => {+ const {+ flow,+ getRedirectUri,+ getState,+ callbackStarted,+ releaseHandleCallback,+ } = startBlockedFlow();+ const redirectUri = await waitForListen(getRedirectUri);+ const flowOutcome = flow.then(+ () => "resolved",+ (error) => `rejected: ${error.message}`+ );++ const validResponsePromise = fetch(`${redirectUri}/?code=ok&state=${getState()}`, {+ redirect: "manual",+ });+ await callbackStarted;++ let malformedStatus;+ let outcomeBeforeRelease;+ try {+ malformedStatus = await requestPath(redirectUri, "//[");+ outcomeBeforeRelease = await Promise.race([+ flowOutcome,+ new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),+ ]);+ } finally {+ releaseHandleCallback();+ }++ const validResponse = await validResponsePromise;+ assert.equal(malformedStatus, 400);+ assert.equal(outcomeBeforeRelease, "pending");+ assert.equal(validResponse.status, 302);+ assert.equal(await flowOutcome, "resolved");+});++test("a second valid callback cannot start another token exchange", async () => {+ const {+ flow,+ getRedirectUri,+ getState,+ callbackStarted,+ getCallbackCount,+ releaseHandleCallback,+ } = startBlockedFlow();+ const redirectUri = await waitForListen(getRedirectUri);+ const flowOutcome = flow.then(+ (result) => ({ status: "resolved", result }),+ (error) => ({ status: "rejected", error: error.message })+ );++ const firstResponsePromise = fetch(`${redirectUri}/?code=first&state=${getState()}`, {+ redirect: "manual",+ });+ await callbackStarted;++ let duplicateResponse;+ let outcomeBeforeRelease;+ try {+ duplicateResponse = await fetch(`${redirectUri}/?code=duplicate&state=${getState()}`, {+ redirect: "manual",+ });+ outcomeBeforeRelease = await Promise.race([+ flowOutcome,+ new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),+ ]);+ } finally {+ releaseHandleCallback();+ }++ const firstResponse = await firstResponsePromise;+ assert.equal(duplicateResponse.status, 400);+ assert.equal(outcomeBeforeRelease, "pending");+ assert.equal(getCallbackCount(), 1);+ assert.equal(firstResponse.status, 302);+ assert.deepEqual(await flowOutcome, {+ status: "resolved",+ result: { code: "first" },+ });+});++test("an accepted callback cannot run after a malformed request rejects the flow", async () => {+ let callbackCount = 0;+ const { flow, server, getRedirectUri, getState } = startFlow(async () => {+ callbackCount += 1;+ return { ok: true };+ });+ const redirectUri = await waitForListen(getRedirectUri);+ const parkedRequest = await parkPartialRequest(redirectUri, server);+ const rejected = assert.rejects(flow, /Invalid URL/);++ try {+ assert.equal(await requestPath(redirectUri, "//["), 302);+ await rejected;++ const lateStatus = await parkedRequest.complete(`?code=late&state=${getState()}`);+ assert.equal(lateStatus, 400);+ assert.equal(callbackCount, 0);+ } finally {+ parkedRequest.destroy();+ }+});++test("an accepted callback cannot run after the flow times out", async () => {+ let callbackCount = 0;+ const { flow, server, getRedirectUri, getState, triggerTimeout } = startFlowWithControlledTimeout(+ async () => {+ callbackCount += 1;+ return { ok: true };+ }+ );+ const redirectUri = await waitForListen(getRedirectUri);+ const parkedRequest = await parkPartialRequest(redirectUri, server);+ const rejected = assert.rejects(flow, /OAuth flow timed out/);++ try {+ triggerTimeout();+ await rejected;++ const lateStatus = await parkedRequest.complete(`?code=late&state=${getState()}`);+ assert.equal(lateStatus, 400);+ assert.equal(callbackCount, 0);+ } finally {+ parkedRequest.destroy();+ }+});