fix(workspace): block symlink escapes in workspace protocol

Signed-off-by: hqhq1025 <1506751656@qq.com>

Author: hqhq1025

apps/desktop/src/main/workspace-protocol.test.ts

@@ -1,8 +1,8 @@
-import { mkdtemp, writeFile } from 'node:fs/promises';
+import { mkdtemp, realpath, symlink, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { resolveWorkspaceUrl } from './workspace-protocol';
+import { resolveWorkspaceRealPath, resolveWorkspaceUrl } from './workspace-protocol';
 
 describe('resolveWorkspaceUrl', () => {
   let workspaceDir: string;
@@ -163,4 +163,32 @@ describe('resolveWorkspaceUrl', () => {
     expect(r.ok).toBe(true);
     if (r.ok) expect(r.value.relPath).toBe('My File.html');
   });
+
+  it('rejects symlinks that resolve outside the workspace', async () => {
+    const outsideDir = await mkdtemp(path.join(os.tmpdir(), 'oc-wsproto-outside-'));
+    const outsideFile = path.join(outsideDir, 'secret.html');
+    await writeFile(outsideFile, '<html>secret</html>');
+    await symlink(outsideFile, path.join(workspaceDir, 'linked.html'));
+
+    const r = resolveWorkspaceUrl(`workspace://${designId}/linked.html`, resolveWorkspace);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+
+    const checked = await resolveWorkspaceRealPath(r.value);
+    expect(checked).toEqual({ ok: false, error: 'traversal' });
+  });
+
+  it('accepts symlinks that stay inside the workspace', async () => {
+    await writeFile(path.join(workspaceDir, 'target.html'), '<html>target</html>');
+    await symlink(path.join(workspaceDir, 'target.html'), path.join(workspaceDir, 'inside.html'));
+
+    const r = resolveWorkspaceUrl(`workspace://${designId}/inside.html`, resolveWorkspace);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+
+    const checked = await resolveWorkspaceRealPath(r.value);
+    expect(checked.ok).toBe(true);
+    if (checked.ok)
+      expect(checked.value.absPath).toBe(await realpath(path.join(workspaceDir, 'target.html')));
+  });
 });

apps/desktop/src/main/workspace-protocol.ts

@@ -1,4 +1,4 @@
-import { readFile } from 'node:fs/promises';
+import { readFile, realpath } from 'node:fs/promises';
 import path_module from 'node:path';
 import type { CoreLogger } from '@open-codesign/core';
 import type Database from 'better-sqlite3';
@@ -97,6 +97,7 @@ export interface WorkspaceResolution {
   mime: string;
   designId: string;
   relPath: string;
+  workspacePath: string;
 }
 
 export interface WorkspaceResolveResult {
@@ -163,7 +164,31 @@ export function resolveWorkspaceUrl(
     return { ok: false, error: 'unsupported_mime' };
   }
 
-  return { ok: true, value: { absPath, mime, designId, relPath } };
+  return {
+    ok: true,
+    value: { absPath, mime, designId, relPath, workspacePath: normalizedWorkspace },
+  };
+}
+
+export async function resolveWorkspaceRealPath(
+  resolution: WorkspaceResolution,
+): Promise<WorkspaceResolveResult | WorkspaceResolveFailure> {
+  const realWorkspace = await realpath(resolution.workspacePath);
+  const realAbsPath = await realpath(resolution.absPath);
+  const sep = path_module.sep;
+  const isInside =
+    realAbsPath === realWorkspace || realAbsPath.startsWith(`${realWorkspace}${sep}`);
+  if (!isInside) {
+    return { ok: false, error: 'traversal' };
+  }
+  return {
+    ok: true,
+    value: {
+      ...resolution,
+      absPath: realAbsPath,
+      workspacePath: realWorkspace,
+    },
+  };
 }
 
 export function registerWorkspaceScheme(): void {
@@ -225,15 +250,24 @@ export function registerWorkspaceProtocolHandler(opts: RegisterWorkspaceProtocol
     }
 
     try {
-      const data = await readFile(result.value.absPath);
-      const isHtml = result.value.mime.startsWith('text/html');
+      const realPathResult = await resolveWorkspaceRealPath(result.value);
+      if (!realPathResult.ok) {
+        logger.warn('workspace.protocol.reject', { url: request.url, error: realPathResult.error });
+        return new Response(realPathResult.error, {
+          status: 403,
+          headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+        });
+      }
+
+      const data = await readFile(realPathResult.value.absPath);
+      const isHtml = realPathResult.value.mime.startsWith('text/html');
       const body: string | Uint8Array = isHtml
         ? `${data.toString('utf8')}${WORKSPACE_NAV_INTERCEPT_SCRIPT}`
         : (data as unknown as Uint8Array);
       return new Response(body, {
         status: 200,
         headers: {
-          'Content-Type': result.value.mime,
+          'Content-Type': realPathResult.value.mime,
           // Iframe is sandboxed (opaque origin); permissive CORS keeps fetch()
           // and dynamic <script> imports working when pages need them.
           'Access-Control-Allow-Origin': '*',