Skip to content

Commit c2d269a

Browse files
committed
fix(desktop): keep Clerk token files private
electron-store writes clerk-tokens.json as mode 0666 on every update, and a later chmod does not stick. Store the file in a 0700 directory, reapply 0600 after each read or write, and tighten a token file already in the state directory. Fixes #15143
1 parent effb433 commit c2d269a

4 files changed

Lines changed: 238 additions & 10 deletions

File tree

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,111 @@
1+
// @effect-diagnostics nodeBuiltinImport:off -- These tests assert real POSIX modes on a temporary directory.
2+
import * as NodeFS from "node:fs";
3+
import * as NodeOS from "node:os";
4+
import * as NodePath from "node:path";
5+
import { assert, describe, it } from "@effect/vitest";
6+
7+
import { openClerkTokenStorage, type ClerkTokenStorage } from "./ClerkTokenStore.ts";
8+
9+
// oxlint-disable-next-line t3code/no-global-process-runtime -- Unix mode bits are the assertion; Windows reports them through ACLs.
10+
const describePosix = describe.skipIf(process.platform === "win32");
11+
12+
const modeOf = (path: string): number => NodeFS.statSync(path).mode & 0o777;
13+
14+
function writeLoose(path: string, contents: string): void {
15+
NodeFS.writeFileSync(path, contents, { mode: 0o666 });
16+
NodeFS.chmodSync(path, 0o666);
17+
}
18+
19+
async function withStateDir(run: (stateDir: string) => Promise<void> | void): Promise<void> {
20+
const stateDir = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "t3-clerk-tokens-"));
21+
try {
22+
await run(stateDir);
23+
} finally {
24+
NodeFS.rmSync(stateDir, { recursive: true, force: true });
25+
}
26+
}
27+
28+
const idleStorage = (): ClerkTokenStorage => ({
29+
getItem: async () => null,
30+
setItem: async () => undefined,
31+
removeItem: () => undefined,
32+
});
33+
34+
describePosix("ClerkTokenStore", () => {
35+
it("keeps clerk tokens at 0600 inside a 0700 directory", async () => {
36+
await withStateDir(async (stateDir) => {
37+
NodeFS.chmodSync(stateDir, 0o755);
38+
const directory = NodePath.join(stateDir, "clerk");
39+
const legacyPath = NodePath.join(stateDir, "clerk-tokens.json");
40+
const tokenPath = NodePath.join(directory, "clerk-tokens.json");
41+
NodeFS.mkdirSync(directory, { mode: 0o755 });
42+
NodeFS.chmodSync(directory, 0o755);
43+
writeLoose(legacyPath, '{"__clerk_client_jwt":"enc:existing"}\n');
44+
45+
const opened: string[] = [];
46+
const storage = openClerkTokenStorage(stateDir, (cwd) => {
47+
opened.push(cwd);
48+
return {
49+
getItem: async () => {
50+
writeLoose(tokenPath, "from-get");
51+
return "from-get";
52+
},
53+
setItem: (_key, value) => {
54+
writeLoose(tokenPath, value);
55+
},
56+
removeItem: () => {
57+
NodeFS.rmSync(tokenPath, { force: true });
58+
},
59+
};
60+
});
61+
62+
assert.deepEqual(opened, [directory]);
63+
assert.equal(modeOf(stateDir), 0o755);
64+
assert.equal(modeOf(directory), 0o700);
65+
assert.equal(modeOf(tokenPath), 0o600);
66+
assert.equal(NodeFS.existsSync(legacyPath), false);
67+
assert.equal(
68+
NodeFS.readFileSync(tokenPath, "utf8"),
69+
'{"__clerk_client_jwt":"enc:existing"}\n',
70+
);
71+
72+
assert.equal(await storage.getItem("client"), "from-get");
73+
assert.equal(modeOf(tokenPath), 0o600);
74+
await storage.setItem("client", "from-set");
75+
assert.equal(modeOf(tokenPath), 0o600);
76+
assert.equal(NodeFS.readFileSync(tokenPath, "utf8"), "from-set");
77+
storage.removeItem("client");
78+
assert.equal(NodeFS.existsSync(tokenPath), false);
79+
80+
writeLoose(tokenPath, "kept");
81+
writeLoose(legacyPath, "stale");
82+
NodeFS.chmodSync(directory, 0o755);
83+
openClerkTokenStorage(stateDir, () => idleStorage());
84+
assert.equal(modeOf(directory), 0o700);
85+
assert.equal(modeOf(tokenPath), 0o600);
86+
assert.equal(modeOf(legacyPath), 0o600);
87+
assert.equal(NodeFS.readFileSync(tokenPath, "utf8"), "kept");
88+
assert.equal(NodeFS.readFileSync(legacyPath, "utf8"), "stale");
89+
});
90+
});
91+
92+
it("does not follow a symlinked clerk directory or token file", async () => {
93+
await withStateDir(async (stateDir) => {
94+
const outsideDirectory = NodePath.join(stateDir, "outside-dir");
95+
NodeFS.mkdirSync(outsideDirectory, { mode: 0o755 });
96+
NodeFS.chmodSync(outsideDirectory, 0o755);
97+
NodeFS.symlinkSync(outsideDirectory, NodePath.join(stateDir, "clerk"));
98+
99+
assert.throws(() => openClerkTokenStorage(stateDir, idleStorage), /must be a real directory/);
100+
assert.equal(modeOf(outsideDirectory), 0o755);
101+
NodeFS.unlinkSync(NodePath.join(stateDir, "clerk"));
102+
103+
const outsideFile = NodePath.join(stateDir, "outside.json");
104+
NodeFS.writeFileSync(outsideFile, "secret", { mode: 0o644 });
105+
NodeFS.chmodSync(outsideFile, 0o644);
106+
NodeFS.symlinkSync(outsideFile, NodePath.join(stateDir, "clerk-tokens.json"));
107+
assert.throws(() => openClerkTokenStorage(stateDir, idleStorage), /must be a regular file/);
108+
assert.equal(modeOf(outsideFile), 0o644);
109+
});
110+
});
111+
});
Lines changed: 117 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
// @effect-diagnostics nodeBuiltinImport:off -- The Clerk bridge must lock the token file down before startup can yield to Electron's ready event.
2+
import * as NodeFS from "node:fs";
3+
import * as NodePath from "node:path";
4+
5+
/**
6+
* `@clerk/electron/storage` persists tokens with electron-store. Its `conf`
7+
* dependency writes `clerk-tokens.json` using `configFileMode` `0o666` and
8+
* applies that mode with chmod, so the process umask never tightens it and the
9+
* next `store.set` puts `0666` back. A `0700` directory is the boundary that
10+
* survives those writes. `0600` is reapplied after every storage call, and an
11+
* existing token file in the state directory is tightened and moved in.
12+
*
13+
* Windows ignores Unix mode bits except for the read-only attribute. Other
14+
* users are kept out by the profile ACL; `0600` still leaves the owner write bit set.
15+
*/
16+
17+
const CLERK_TOKEN_DIRECTORY_MODE = 0o700;
18+
const CLERK_TOKEN_FILE_MODE = 0o600;
19+
const CLERK_TOKEN_DIRECTORY_NAME = "clerk";
20+
const CLERK_TOKEN_FILE_NAME = "clerk-tokens.json";
21+
22+
type Awaitable<T> = T | Promise<T>;
23+
24+
export interface ClerkTokenStorage {
25+
readonly getItem: (key: string) => Awaitable<string | null>;
26+
readonly setItem: (key: string, value: string) => Awaitable<void>;
27+
readonly removeItem: (key: string) => Awaitable<void>;
28+
}
29+
30+
function isErrno(error: unknown, code: string): boolean {
31+
return typeof error === "object" && error !== null && "code" in error && error.code === code;
32+
}
33+
34+
function lstatIfExists(path: string): NodeFS.Stats | undefined {
35+
try {
36+
return NodeFS.lstatSync(path);
37+
} catch (error) {
38+
if (isErrno(error, "ENOENT")) return undefined;
39+
throw error;
40+
}
41+
}
42+
43+
function assertRegularFile(path: string, stat: NodeFS.Stats): void {
44+
if (stat.isSymbolicLink() || !stat.isFile()) {
45+
throw new Error(`Clerk token file "${path}" must be a regular file.`);
46+
}
47+
}
48+
49+
function restrictClerkTokenFile(path: string): void {
50+
const stat = lstatIfExists(path);
51+
if (stat === undefined) return;
52+
assertRegularFile(path, stat);
53+
if ((stat.mode & 0o777) === CLERK_TOKEN_FILE_MODE) return;
54+
NodeFS.chmodSync(path, CLERK_TOKEN_FILE_MODE);
55+
}
56+
57+
function migrateLegacyClerkTokenFile(stateDir: string, directory: string): void {
58+
const legacyPath = NodePath.join(stateDir, CLERK_TOKEN_FILE_NAME);
59+
const tokenPath = NodePath.join(directory, CLERK_TOKEN_FILE_NAME);
60+
const legacy = lstatIfExists(legacyPath);
61+
if (legacy !== undefined) {
62+
assertRegularFile(legacyPath, legacy);
63+
NodeFS.chmodSync(legacyPath, CLERK_TOKEN_FILE_MODE);
64+
}
65+
66+
const destination = lstatIfExists(tokenPath);
67+
if (destination === undefined) {
68+
if (legacy === undefined) return;
69+
try {
70+
NodeFS.renameSync(legacyPath, tokenPath);
71+
} catch (error) {
72+
if (!isErrno(error, "ENOENT")) throw error;
73+
}
74+
return;
75+
}
76+
77+
assertRegularFile(tokenPath, destination);
78+
NodeFS.chmodSync(tokenPath, CLERK_TOKEN_FILE_MODE);
79+
}
80+
81+
function restrictAfter<T>(run: () => Awaitable<T>, tighten: () => void): Awaitable<T> {
82+
let result: Awaitable<T>;
83+
try {
84+
result = run();
85+
} catch (error) {
86+
tighten();
87+
throw error;
88+
}
89+
if (result instanceof Promise) return result.finally(tighten);
90+
tighten();
91+
return result;
92+
}
93+
94+
/** Opens Clerk token storage in a private directory and keeps the file at `0600`. */
95+
export function openClerkTokenStorage(
96+
stateDir: string,
97+
createStorage: (directory: string) => ClerkTokenStorage,
98+
): ClerkTokenStorage {
99+
const directory = NodePath.join(stateDir, CLERK_TOKEN_DIRECTORY_NAME);
100+
NodeFS.mkdirSync(directory, { recursive: true, mode: CLERK_TOKEN_DIRECTORY_MODE });
101+
const stat = NodeFS.lstatSync(directory);
102+
if (stat.isSymbolicLink() || !stat.isDirectory()) {
103+
throw new Error(`Clerk token directory "${directory}" must be a real directory.`);
104+
}
105+
NodeFS.chmodSync(directory, CLERK_TOKEN_DIRECTORY_MODE);
106+
migrateLegacyClerkTokenFile(stateDir, directory);
107+
const tokenPath = NodePath.join(directory, CLERK_TOKEN_FILE_NAME);
108+
restrictClerkTokenFile(tokenPath);
109+
110+
const storage = createStorage(directory);
111+
const tighten = () => restrictClerkTokenFile(tokenPath);
112+
return {
113+
getItem: (key) => restrictAfter(() => storage.getItem(key), tighten),
114+
setItem: (key, value) => restrictAfter(() => storage.setItem(key, value), tighten),
115+
removeItem: (key) => restrictAfter(() => storage.removeItem(key), tighten),
116+
};
117+
}

‎apps/desktop/src/app/DesktopClerk.test.ts‎

Lines changed: 8 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -190,16 +190,15 @@ describe("DesktopClerk", () => {
190190
return Effect.gen(function* () {
191191
yield* Effect.scoped(Layer.build(layerDesktopClerk(true, events)));
192192

193-
assert.deepEqual(createClerkBridgeMock.mock.calls, [
194-
[
195-
{
196-
storage: storageAdapter,
197-
manageSingleInstanceLock: false,
198-
passkeys: true,
199-
renderer: { scheme: "t3code-dev", host: "app" },
200-
},
201-
],
193+
assert.deepEqual(storageMock.mock.calls, [
194+
[{ path: NodePath.join("/tmp/t3-state", "clerk") }],
202195
]);
196+
const bridgeOptions = createClerkBridgeMock.mock.calls[0]?.[0];
197+
assert.notStrictEqual(bridgeOptions?.storage, storageAdapter);
198+
assert.equal(bridgeOptions?.manageSingleInstanceLock, false);
199+
assert.equal(bridgeOptions?.passkeys, true);
200+
assert.deepEqual(bridgeOptions?.renderer, { scheme: "t3code-dev", host: "app" });
201+
assert.equal(createClerkBridgeMock.mock.calls.length, 1);
203202
assert.equal(cleanup.mock.calls.length, 1);
204203
assert.deepEqual(events, [
205204
"setPath:userData:/tmp/app-data/t3code-dev",

‎apps/desktop/src/app/DesktopClerk.ts‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
2020
import * as ElectronWindow from "../electron/ElectronWindow.ts";
2121
import * as DesktopUserData from "./DesktopUserData.ts";
2222
import * as DesktopEnvironment from "./DesktopEnvironment.ts";
23+
import { openClerkTokenStorage } from "./ClerkTokenStore.ts";
2324
import * as DesktopWebLinks from "./DesktopWebLinks.ts";
2425

2526
declare const __T3CODE_BUILD_CLERK_PUBLISHABLE_KEY__: string | undefined;
@@ -85,7 +86,7 @@ export const desktopClerkFrontendApiHostname = resolveDesktopClerkFrontendApiHos
8586

8687
function createDesktopClerkBridge(stateDir: string, isDevelopment: boolean) {
8788
return createClerkBridge({
88-
storage: storage({ path: stateDir }),
89+
storage: openClerkTokenStorage(stateDir, (directory) => storage({ path: directory })),
8990
manageSingleInstanceLock: false,
9091
passkeys: true,
9192
renderer: {

0 commit comments

Comments
 (0)