@goodandready/dsh-remote-workspace 0.3.15 → 0.3.16

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.3.16
+
+### Security & Hardening
+- **Strict environment file matching in `/env/save` (#119)**: Replaced loose substring check (`baseName.includes('env')`) with exact filename validation (`isEnvFileName`: `.env`, `.env.<suffix>`, or `*.env`), preventing arbitrary file writes to paths such as `/any/dir/env` or `environment.json`.
+- **Constant-time token comparison (#119)**: Introduced `timingSafeCompare` using `node:crypto.timingSafeEqual` for Bearer and Cookie token validation in `isTrustedSettingsRequest` (`lib/routes/helpers.js`).
+- **Absolute remoteWorkspace enforcement (#119)**: Required `remoteWorkspace` in `resolveWorkspacePath` (`lib/tools.js`) to be an explicit absolute POSIX path starting with `/`, eliminating cwd-dependent path resolution.
+- **SFTP realpath symlink-escape protection (#119)**: Added `RemoteFsService.realpath` and canonical path boundary verification (`verifyWorkspaceRealpath`) in `remote_fs` tool to block symlink targets (and symlinked parent directories on write/mkdir) that resolve outside the configured `remoteWorkspace`.
+
+
 ## 0.3.15
 
 ### Security & Hardening

package/lib/remote-fs-service.js

@@ -80,6 +80,22 @@ export class RemoteFsService {
     });
   }
 
+  /**
+   * Resolve canonical realpath on remote host via SFTP
+   */
+  async realpath(profile, remotePath) {
+    const sftp = await this.sshService.getSftp(profile);
+    if (!sftp || typeof sftp.realpath !== 'function') {
+      return path.posix.normalize(remotePath);
+    }
+    return new Promise((resolve, reject) => {
+      sftp.realpath(remotePath, (err, absPath) => {
+        if (err) return reject(err);
+        resolve(absPath);
+      });
+    });
+  }
+
   /**
    * Stat remote path with cache
    */

package/lib/routes/env.js

@@ -1,12 +1,17 @@
 import { writeJson, readBody, authorizeRequest, validateRemotePath } from './helpers.js';
 
-export function registerEnvRoutes(sctx, webServer, { envService, diagnoseService, store, remoteFs }) {
+export function isEnvFileName(baseName) {
+  if (typeof baseName !== 'string' || !baseName) return false;
+  return baseName === '.env' || baseName.startsWith('.env.') || baseName.endsWith('.env');
+}
+
+export function registerEnvRoutes(sctx, webServer, { envService, diagnoseService, sshService, store, remoteFs }) {
   // 10. POST /dsh-remote-workspace/env/view
   sctx.effect(() => webServer.register({
     kind: 'exact',
     path: '/dsh-remote-workspace/env/view',
     handler: async (req, res) => {
-      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' });
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'Method Not Allowed' });
       if (!authorizeRequest(sctx, req, res)) return;
       try {
         const { profileId, remotePath } = await readBody(req);
@@ -17,17 +22,18 @@ export function registerEnvRoutes(sctx, webServer, { envService, diagnoseService
         const result = await envService.readEnv(profile, targetPath);
         writeJson(res, 200, { ok: true, ...result });
       } catch (err) {
-        writeJson(res, err.statusCode || (err.name === 'SyntaxError' ? 400 : 500), { ok: false, error: err.message });
+        const status = err.statusCode || err.status || 500;
+        writeJson(res, status, { ok: false, error: err.message });
       }
     }
-  }), 'dsh-remote-workspace: /env/view');
+  }), 'dsh-remote-workspace:route:env-view');
 
   // 11. POST /dsh-remote-workspace/env/save
   sctx.effect(() => webServer.register({
     kind: 'exact',
     path: '/dsh-remote-workspace/env/save',
     handler: async (req, res) => {
-      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' });
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'Method Not Allowed' });
       if (!authorizeRequest(sctx, req, res)) return;
       try {
         const { profileId, remotePath, content, key, value } = await readBody(req);
@@ -36,7 +42,7 @@ export function registerEnvRoutes(sctx, webServer, { envService, diagnoseService
         const defaultPath = profile.remoteWorkspace ? `${profile.remoteWorkspace.replace(/\/+$/, '')}/.env` : '.env';
         const targetPath = validateRemotePath(remotePath || defaultPath);
         const baseName = targetPath.split('/').pop();
-        if (!baseName.includes('env')) {
+        if (!isEnvFileName(baseName)) {
           return writeJson(res, 400, { ok: false, error: 'Target path must be an environment file' });
         }
         let result;
@@ -49,34 +55,35 @@ export function registerEnvRoutes(sctx, webServer, { envService, diagnoseService
           if (remoteFs && typeof remoteFs.writeFile === 'function') {
             await remoteFs.writeFile(profile, targetPath, content);
           }
-          result = { ok: true, filePath: targetPath };
+          result = { filePath: targetPath, updated: true };
         } else {
-          return writeJson(res, 400, { ok: false, error: 'Either key/value or content is required' });
+          return writeJson(res, 400, { ok: false, error: 'Either key or content must be provided' });
         }
         writeJson(res, 200, { ok: true, ...result });
       } catch (err) {
-        writeJson(res, err.statusCode || (err.name === 'SyntaxError' ? 400 : 500), { ok: false, error: err.message });
+        const status = err.statusCode || err.status || 500;
+        writeJson(res, status, { ok: false, error: err.message });
       }
     }
-  }), 'dsh-remote-workspace: /env/save');
+  }), 'dsh-remote-workspace:route:env-save');
 
   // 12. POST /dsh-remote-workspace/diagnose
   sctx.effect(() => webServer.register({
     kind: 'exact',
     path: '/dsh-remote-workspace/diagnose',
     handler: async (req, res) => {
-      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' });
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'Method Not Allowed' });
       if (!authorizeRequest(sctx, req, res)) return;
       try {
-        const { profileId, category, checks, target } = await readBody(req);
+        const { profileId, category, target } = await readBody(req);
         const profile = store.getProfile(profileId);
         if (!profile) return writeJson(res, 404, { ok: false, error: 'Profile not found' });
-        const checkCategory = category || checks || 'memory';
-        const result = await diagnoseService.diagnose(profile, checkCategory, target || '');
+        const result = await diagnoseService.diagnose(profile, category, target);
         writeJson(res, 200, { ok: true, ...result });
       } catch (err) {
-        writeJson(res, err.statusCode || (err.name === 'SyntaxError' ? 400 : 500), { ok: false, error: err.message });
+        const status = err.statusCode || err.status || 500;
+        writeJson(res, status, { ok: false, error: err.message });
       }
     }
-  }), 'dsh-remote-workspace: /diagnose');
+  }), 'dsh-remote-workspace:route:diagnose');
 }

package/lib/routes/helpers.js

@@ -1,3 +1,16 @@
+import { timingSafeEqual } from 'node:crypto';
+
+export function timingSafeCompare(a, b) {
+  if (typeof a !== 'string' || typeof b !== 'string') return false;
+  const bufA = Buffer.from(a, 'utf8');
+  const bufB = Buffer.from(b, 'utf8');
+  if (bufA.length !== bufB.length) {
+    timingSafeEqual(bufA, bufA);
+    return false;
+  }
+  return timingSafeEqual(bufA, bufB);
+}
+
 export function writeJson(res, statusCode, body) {
   if (typeof res.setHeader === 'function') {
     res.setHeader('Content-Type', 'application/json; charset=utf-8');
@@ -111,7 +124,7 @@ export function isTrustedSettingsRequest(req, expectedToken = null) {
   const rawAuth = headers['authorization'];
   if (typeof rawAuth === 'string' && rawAuth.startsWith('Bearer ')) {
     const bearer = rawAuth.slice(7).trim();
-    if (tokenCandidate && bearer && bearer === tokenCandidate) {
+    if (tokenCandidate && bearer && timingSafeCompare(bearer, tokenCandidate)) {
       return true;
     }
   }
@@ -120,7 +133,7 @@ export function isTrustedSettingsRequest(req, expectedToken = null) {
   if (typeof cookieHeader === 'string' && tokenCandidate) {
     const cookies = parseCookies(cookieHeader);
     const token = cookies['token'] || cookies['dsh_token'];
-    if (token && token === tokenCandidate) {
+    if (token && timingSafeCompare(token, tokenCandidate)) {
       return true;
     }
   }

package/lib/routes.js

@@ -8,7 +8,7 @@ import { registerTunnelRoutes } from './routes/tunnels.js';
 import { registerDockerRoutes } from './routes/docker.js';
 import { registerSyncRoutes } from './routes/sync.js';
 
-export { isTrustedSettingsRequest, authorizeRequest, readBody, MAX_BODY_BYTES } from './routes/helpers.js';
+export { isTrustedSettingsRequest, authorizeRequest, readBody, MAX_BODY_BYTES, timingSafeCompare } from './routes/helpers.js';
 
 export function registerApiRoutes(
   ctx,

package/lib/tools.js

@@ -5,25 +5,76 @@ import { renderHostTable } from './host-projection.js';
 import { filterClusterProfiles, runCluster } from './cluster-service.js';
 
 
+export function isWithinWorkspace(normWorkspace, candidatePath) {
+  const normCandidate = path.posix.normalize(candidatePath);
+  const prefix = normWorkspace.endsWith('/') ? normWorkspace : normWorkspace + '/';
+  return normCandidate === normWorkspace || normCandidate.startsWith(prefix);
+}
+
 export function resolveWorkspacePath(workspace, targetPath) {
   if (!workspace || typeof workspace !== 'string' || !workspace.trim()) {
     throw new Error('Remote workspace is not configured for active profile');
   }
+  const trimmedWorkspace = workspace.trim();
+  if (trimmedWorkspace.includes('\0') || !path.posix.isAbsolute(trimmedWorkspace)) {
+    throw new Error('Remote workspace must be an absolute path starting with "/"');
+  }
   if (!targetPath || typeof targetPath !== 'string' || targetPath.includes('\0')) {
     throw new Error('Path must be a non-empty string without null bytes');
   }
-  const normWorkspace = path.posix.normalize(workspace.trim());
+  const normWorkspace = path.posix.normalize(trimmedWorkspace);
   const resolved = path.posix.isAbsolute(targetPath)
     ? path.posix.normalize(targetPath)
     : path.posix.resolve(normWorkspace, targetPath);
 
-  const prefix = normWorkspace.endsWith('/') ? normWorkspace : normWorkspace + '/';
-  if (resolved !== normWorkspace && !resolved.startsWith(prefix)) {
+  if (!isWithinWorkspace(normWorkspace, resolved)) {
     throw new Error(`Access denied: path "${targetPath}" is outside configured remoteWorkspace "${workspace}"`);
   }
   return resolved;
 }
 
+export async function verifyWorkspaceRealpath(remoteFs, profile, workspace, resolvedPath, targetPath) {
+  if (!remoteFs || typeof remoteFs.realpath !== 'function') {
+    return resolvedPath;
+  }
+  const normWorkspace = path.posix.normalize(workspace.trim());
+  let realWorkspace = normWorkspace;
+  try {
+    const resolvedWs = await remoteFs.realpath(profile, normWorkspace);
+    if (resolvedWs && typeof resolvedWs === 'string') {
+      realWorkspace = path.posix.normalize(resolvedWs);
+    }
+  } catch (_err) {
+    // Fallback to normalized configured workspace if workspace root itself cannot be resolved yet
+  }
+
+  let checkPath = resolvedPath;
+  let realCandidate = null;
+  try {
+    realCandidate = await remoteFs.realpath(profile, checkPath);
+  } catch (_err) {
+    // For non-existent leaf targets (e.g., write / mkdir), verify the parent directory realpath
+    const parentPath = path.posix.dirname(checkPath);
+    try {
+      const realParent = await remoteFs.realpath(profile, parentPath);
+      if (realParent && typeof realParent === 'string') {
+        realCandidate = path.posix.join(realParent, path.posix.basename(checkPath));
+      }
+    } catch (_parentErr) {
+      realCandidate = null;
+    }
+  }
+
+  if (realCandidate && typeof realCandidate === 'string') {
+    const normReal = path.posix.normalize(realCandidate);
+    if (!isWithinWorkspace(realWorkspace, normReal)) {
+      throw new Error(`Access denied: symlink target "${normReal}" for path "${targetPath}" escapes configured remoteWorkspace "${workspace}"`);
+    }
+    return normReal;
+  }
+  return resolvedPath;
+}
+
 export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile, getProfileById, dockerService, diagnoseService, envService, tarSyncService, listProfiles = null) {
   if (!ctx.tools || typeof ctx.tools.register !== 'function') {
     return;
@@ -93,8 +144,13 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
       if (!profile) throw new Error('No active remote workspace profile selected');
       const { action, path: targetPath, content, recursive, bypassCache } = args;
 
-      const resolvedPath = resolveWorkspacePath(profile.remoteWorkspace, targetPath);
-      if (action === 'remove' && resolvedPath === path.posix.normalize(profile.remoteWorkspace.trim())) {
+      const lexicalPath = resolveWorkspacePath(profile.remoteWorkspace, targetPath);
+      const normWs = path.posix.normalize(profile.remoteWorkspace.trim());
+      if (action === 'remove' && lexicalPath === normWs) {
+        throw new Error('Cannot remove root workspace directory');
+      }
+      const resolvedPath = await verifyWorkspaceRealpath(remoteFs, profile, profile.remoteWorkspace, lexicalPath, targetPath);
+      if (action === 'remove' && resolvedPath === normWs) {
         throw new Error('Cannot remove root workspace directory');
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-remote-workspace",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "description": "Enterprise Remote Workspace Plugin for DeepSeek Harness: SSH2 connection pool, SFTP operations, 3-way conflict-aware mirror sync, port forwarding, and native DSH UI.",
   "type": "module",
   "main": "lib/index.js",