// Build step for the merged bundle: produce lib/remote-ssh/index.js from the // vendored upstream host half (vendor/dsh-remote-ssh/lib/index.js, kept // pristine) with the bundle's local patch set applied. Every edit is // anchor-asserted: if upstream changes the anchored code, the build fails // loudly instead of silently shipping an unpatched file. // // Patch 1 — canonical remote-path identity in createRemoteWorkspace: // upstream's issue-#32 reuse lookup compares remotePath as a raw string, so // the same remote directory spelled two ways (~/proj vs /home/u/proj vs // proj/) registers a second workspace record, a second local mirror and a // second native workspace — the "duplicate folder" bug. The patch compares // light-normalized spellings first; on a miss it resolves the path once // over SSH (pwd -P + $HOME) and compares canonical forms, storing the // canonical spelling so records converge. Resolution failures are // fail-open: creation proceeds with the light form, exactly as upstream, // never blocked. // // Patch 2 — ssh argv hardening in sshArgv (the single constructor every // internal connection flows through): // a) "--" is inserted before the user@host target. Profile fields reach // this point from settings, ~/.ssh/config imports and the remote_ssh // tools' inline arguments; a user/host value starting with "-" (e.g. // -oProxyCommand=...) would otherwise be parsed as an ssh option and // execute LOCAL commands, breaking the tools' "remote only" boundary. // b) POSIX password auth uses `sshpass -e` (password via the SSHPASS // environment variable, merged into the spawn env by the caller) // instead of `sshpass -p`, which leaves the password in the process // list, readable by every local user via ps / /proc//cmdline — // on the shared login nodes this plugin targets, that is everyone. // (The Windows path already passes its password via env.) // // Patch 3 — the generated terminal shell wrapper (dsh-remote-shell): // a) The marker file .remote-ssh.json is honored only when the cwd IS a // direct child of the mirror base ~/.dsh/remote-workspaces — exactly // where the host itself writes it. A marker planted in a cloned repo // or any other directory must never auto-connect the user's terminal // to an attacker's server. // b) StrictHostKeyChecking=no becomes accept-new (aligning with the // internal channel): a changed host key fails loudly. // c) "--" before the user@host target, same as patch 2a. // d) remotePath reaches the remote shell base64-encoded and is decoded // there, so its content is data, never shell syntax: quotes, $() and // backticks in a directory name can no longer break out. (~ still // expands on the remote side; a remote without base64 falls back to // $HOME exactly as the old code did when cd failed.) import { mkdirSync, readFileSync, writeFileSync } from 'node:fs' import { dirname, join } from 'node:path' import { fileURLToPath } from 'node:url' const HELPERS = `// --------------------------------------------------------------------------- // [workspace-groups-remote local patch] Canonical remote-path identity. // See scripts/patch-remote-ssh.mjs in the merged bundle for the rationale. // --------------------------------------------------------------------------- /** Light canonical form of a remote path: trimmed, trailing slashes removed. */ function lightRemotePath(raw) { let s = String(raw == null ? "" : raw).trim(); if (s.length > 1) s = s.replace(/\\/+$/, ""); return s; } /** Expand a leading ~ or ~/ with the remote home directory, when known. */ function expandRemoteHome(path, home) { const h = String(home == null ? "" : home).replace(/\\/+$/, ""); if (!h) return path; if (path === "~") return h; if (path.startsWith("~/")) return h + path.slice(1); return path; } /** * Resolve a remote path to its canonical absolute identity through one SSH * round trip (also learns the remote $HOME). Returns a discriminated result: * ok:false is NOT "not a duplicate" — the caller must refuse to create * because it cannot prove the path is distinct. */ async function resolveRemoteCanonical(subprocess, p, rawPath) { const light = lightRemotePath(rawPath); if (!light) return { ok: false, error: "remotePath 为空", home: "" }; try { const cmd = "printf '__DSH_HOME__%s\\n' \\"$HOME\\"; cd " + shellQuotePath(light) + " 2>/dev/null && pwd -P"; const r = await runRemote(subprocess, p, cmd, undefined, 64 * 1024, undefined, 15000); if (!r || !r.ok) { return { ok: false, error: String((r && (r.error || r.stderr)) || "SSH 解析失败").trim() || "SSH 解析失败", home: "" }; } let home = ""; let resolved = ""; const lines = String(r.stdout).split("\\n"); for (const line of lines) { const t = line.trim(); if (t.startsWith("__DSH_HOME__")) home = t.slice("__DSH_HOME__".length).trim(); else if (t.startsWith("/")) resolved = t; } if (!resolved) { // cd failed (missing directory / permission / shell error): identity is // unknown, never silently treated as a new directory. return { ok: false, error: "无法解析远端目录(不存在或不可访问):" + light, home: home }; } return { ok: true, canonical: lightRemotePath(resolved), home: home }; } catch (e) { return { ok: false, error: String(e && e.message ? e.message : e), home: "" }; } } /** * First symlink under the given root whose target resolves outside it, else null. * The sync-down tar stream is remote-controlled: an escaping link extracted * into the temp tree would be followed by the copy/swap that lands the tree * in the mirror, writing outside it. Bounded walk (directory pops capped). */ function findEscapingLink(root) { const base = resolvePath(root); const stack = [base]; let guard = 0; while (stack.length > 0 && guard++ < 20000) { const dir = stack.pop(); let entries; try { entries = readdirSync(dir, { withFileTypes: true }); } catch (e) { continue; } for (const entry of entries) { const full = join(dir, entry.name); if (entry.isSymbolicLink()) { let target; try { target = readlinkSync(full); } catch (e) { continue; } const resolved = resolvePath(dir, target); if (resolved !== base && !resolved.startsWith(base + "/") && !resolved.startsWith(base + "\\\\")) return full; } else if (entry.isDirectory()) { stack.push(full); } } } return null; } ` const RUNREMOTE_ANCHOR = 'async function runRemote(subprocess, p, remoteCmd, stdinData, maxBytes, extraOpts, timeoutMs, signal) {' // Load-time self-check inserted with the helpers: the canonical-path patch // calls upstream internals (runRemote / shellQuotePath) from inside a // fail-open try/catch, so an upstream rename would otherwise degrade // silently to unpatched behavior. Fail loudly at module load instead. const SELF_CHECK = `// [workspace-groups-remote patch] Load-time self-check: if upstream renames // the internals the canonical-path patch relies on, fail loudly HERE rather // than silently degrading inside the fail-open resolution path. if (typeof runRemote !== 'function' || typeof shellQuotePath !== 'function') { throw new Error('[workspace-groups-remote] patched remote-ssh: upstream internals changed (runRemote / shellQuotePath not found) — the bundle patch needs re-checking') } ` const FIND_ANCHOR = ' const existing = prefsNow.workspaces.find((w) => w && w.profileId === a.profileId && String(w.remotePath) === String(a.remotePath));' const FIND_REPLACEMENT = ` // [workspace-groups-remote patch] Canonical-path reuse: resolve the new // spelling once over SSH and resolve every existing record of the same // connection with the same rule (light form + remote $HOME + pwd -P), // so relative/~, trailing-slash and symlink spellings converge on one // directory identity. A resolution failure is NOT "not a duplicate": // creation is refused with an actionable error instead of silently // registering a second workspace. const targetResolved = await resolveRemoteCanonical(subprocess, p, a.remotePath); if (targetResolved.ok !== true) { return { ok: false, error: "无法确认远端路径是否重复:" + targetResolved.error + ";未创建新工作区" }; } const sameProfile = prefsNow.workspaces.filter((w) => w && w.profileId === a.profileId && typeof w.remotePath === "string"); let existing = undefined; for (const record of sameProfile) { const light = lightRemotePath(record.remotePath); // Fast path: the spelling expands to exactly the resolved target. if (expandRemoteHome(light, targetResolved.home) === targetResolved.canonical) { existing = record; break; } // Slow path: resolve the old record with the SAME rules. This catches // relative paths, symlinks and historical spellings the old partial // expansion missed. A failure aborts instead of assuming uniqueness. const candidate = await resolveRemoteCanonical(subprocess, p, record.remotePath); if (candidate.ok !== true) { return { ok: false, error: "无法确认是否与已有远程工作区「" + String(record.title || record.id) + "」重复:" + candidate.error + ";未创建新工作区" }; } if (candidate.canonical === targetResolved.canonical) { existing = record; break; } } a.remotePath = existing ? String(existing.remotePath) : targetResolved.canonical;` // Each entry: [label, anchor, replacement]. Anchors are exact byte strings // from the vendored file; every one must occur exactly once. const TRANSFORMS = [ ['patch 11: settings entry id falls back to the bundle row', 'const entryId = ownEntryId(ctx, name) || NS;', `// [workspace-groups-remote patch] Inside the merged bundle there is no // loader row named dsh-remote-ssh: the settings entry lives on the // bundle's own row, whose composed plugin exports this plugin's Config. // Resolve that row before falling back to the standalone namespace. const entryId = ownEntryId(ctx, name) || ownEntryId(ctx, "workspace-groups-remote") || NS;`], ['patch 2a: sshArgv "--" before target', ' const argv = head.concat(opts, [target]);', ` // [workspace-groups-remote patch] "--" ends ssh option parsing: a // user/host value starting with "-" (e.g. -oProxyCommand=...) must never // be parsed as an ssh option — that would execute local commands. const argv = head.concat(opts, ["--", target]);`], ['patch 2b: sshpass -e instead of -p', ' head = ["sshpass", "-p", String(p.password)];', ` // [workspace-groups-remote patch] sshpass -e: the password travels // via the SSHPASS env var (passwordEnv below is merged into the spawn // env by the caller), not via argv, where any local user could read // it from the process list. Mirrors the Windows env-based path. head = ["sshpass", "-e"]; passwordEnv = { SSHPASS: String(p.password) };`], ['patch 3a: wrapper requires the os module', ' "const { spawn } = require(\'child_process\');",', ` "const { spawn } = require('child_process');", "const os = require('os');",`], ['patch 3a: wrapper only trusts mirror-root marker files', ' " if (fs.existsSync(info)) {",', ` " // [workspace-groups-remote patch] Only a registered mirror root may", " // trigger an automatic connection: the marker file counts solely when", " // the cwd IS a direct child of the mirror base — exactly where the", " // host itself writes it. A .remote-ssh.json planted in a cloned repo", " // or any other directory must never auto-connect the user's terminal.", " const inMirrorRoot = path.dirname(process.cwd()) === path.join(os.homedir(), '.dsh', 'remote-workspaces');", " if (inMirrorRoot && fs.existsSync(info)) {",`], ['patch 3b: wrapper host key checking accept-new', ' " const args = [\'-tt\', \'-o\', \'StrictHostKeyChecking=no\', \'-o\', \'ExitOnForwardFailure=no\'];",', ` " // [workspace-groups-remote patch] accept-new, never 'no': a changed", " // host key must fail loudly instead of being silently trusted.", " const args = ['-tt', '-o', 'StrictHostKeyChecking=accept-new', '-o', 'ExitOnForwardFailure=no'];",`], ['patch 3c: wrapper "--" before target', ' " args.push(\'-p\', String(port), \'-i\', j.keyPath, j.user + \'@\' + j.host);",', ` " // [workspace-groups-remote patch] '--' ends option parsing, so a", " // user/host value starting with '-' can never become an ssh option.", " args.push('-p', String(port), '-i', j.keyPath, '--', j.user + '@' + j.host);",`], ['patch 4: localToRemote folds dot segments, refuses root escape', ` if (rel.startsWith("/")) rel = rel.slice(1); if (!rel) return remoteBase; // 拼接远程路径`, ` if (rel.startsWith("/")) rel = rel.slice(1); if (!rel) return remoteBase; // [workspace-groups-remote patch] Fold "." / ".." segments lexically: // a ".." climbing above the mirror root would map the request OUTSIDE // the remote workspace (e.g. /../../etc/passwd) — refuse // instead of silently following it. const foldedParts = []; for (const seg of rel.split("/")) { if (seg === "" || seg === ".") continue; if (seg === "..") { if (foldedParts.length === 0) throw new Error("remote path escapes the workspace root: " + localPath); foldedParts.pop(); continue; } foldedParts.push(seg); } rel = foldedParts.join("/"); if (!rel) return remoteBase; // 拼接远程路径`], ['patch 5a: writeBack settings comment (fail-closed)', ' // 工作区设置(按镜像目录匹配);读不到设置时按默认(推、无排除)处理', ' // 工作区设置(按镜像目录匹配);读不到设置时不推(fail-closed —— 见下方 catch 的 PATCH 说明)'], ['patch 5b: writeBack settings-read failure fails closed', ` } catch (e) {} // ---- 护栏 B(issue #24 第二轮):推之前先看远端这一份有没有被别的写入者改过 ----`, ` } catch (e) { // [workspace-groups-remote patch] Fail CLOSED: the old empty catch let // a settings-read failure push anyway, with the writeBack guard // (writeBack=false / writeBackExclude) never evaluated. Skip the push // and surface it through the same writeBackFailure channel as a // failed push: "error" throws to the caller, "log" warns, "silent" // stays quiet. const mode = writeBackFailureMode(); if (mode !== "silent") { try { ctx.logger?.warn?.("[dsh-remote-ssh] 读不到工作区设置,写回护栏无法确认,本次不推送: " + String(absPath)); } catch (e2) {} } if (mode === "error") { throw new Error("无法读取工作区设置,写回护栏(writeBack / writeBackExclude)未能确认,本次写入未同步到远端: " + remoteFile); } return; } // ---- 护栏 B(issue #24 第二轮):推之前先看远端这一份有没有被别的写入者改过 ----`], ['patch 6: fs imports for the link scan + atomic rename', 'import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync } from "node:fs";', 'import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, lstatSync, readlinkSync, renameSync } from "node:fs";'], ['patch 7: freshness state written atomically', ` writeFileSync(file, JSON.stringify(data), "utf8"); freshnessCache = { file: file, data: data };`, ` // [workspace-groups-remote patch] Write-then-rename: a crash mid-write // must not leave a torn state file behind. const tmpFile = file + ".tmp-" + process.pid; writeFileSync(tmpFile, JSON.stringify(data), "utf8"); renameSync(tmpFile, file); freshnessCache = { file: file, data: data };`], ['patch 8a: remote stat at nanosecond resolution', ' try { r = await runner(p, "stat -c\'%s %Y\' " + shellQuotePath(remotePath), undefined, 65536, false); } catch (e) {', ' try { r = await runner(p, "stat -c\'%s %Y %N\' " + shellQuotePath(remotePath), undefined, 65536, false); } catch (e) {'], ['patch 8b: stamp carries the nanosecond fraction', ` const m = /^(\\d+)\\s+(\\d+)$/.exec(out); if (r && r.ok && m) return { ok: true, exists: true, stamp: m[1] + ":" + m[2], err: "" };`, ` const m = /^(\\d+)\\s+(\\d+)(?:\\s+(\\d+))?$/.exec(out); if (r && r.ok && m) return { ok: true, exists: true, stamp: m[1] + ":" + m[2] + (m[3] ? "." + m[3] : ""), err: "" };`], ['patch 8c: verdict tolerates pre-upgrade second-resolution stamps', ` if (before && before.ok && before.exists) { if (String(before.stamp) === prev) return { changed: false, unknown: false, why: "" };`, ` if (before && before.ok && before.exists) { if (String(before.stamp) === prev) return { changed: false, unknown: false, why: "" }; // [workspace-groups-remote patch] Stamps recorded before the nanosecond // upgrade carry no fraction — compare those at second precision instead // of reporting a phantom change on every tracked file. if (!prev.includes(".") && String(before.stamp).startsWith(prev + ".")) return { changed: false, unknown: false, why: "" };`], ['patch 9: matchRemoteWorkspace folds case only on Windows', ' const norm = (p) => String(p || "").replace(/\\\\/g, "/").replace(/\\/+$/, "").toLowerCase();', ` // [workspace-groups-remote patch] Fold case only where the filesystem // is case-insensitive (Windows); on POSIX a fold can match a DIFFERENT // workspace whose mirror differs only by letter case. const foldCase = process.platform === "win32"; const norm = (p) => { const v = String(p || "").replace(/\\\\/g, "/").replace(/\\/+$/, ""); return foldCase ? v.toLowerCase() : v; };`], ['patch 10: findMirrorRoot trusts markers only at a real mirror root', ' if (info && info.host && info.user && info.remotePath) return { root: dir, info: info };', ` // [workspace-groups-remote patch] Trust a marker only at a real // mirror root — a directory directly under the mirror base, exactly // where the host writes it. The walk passes through arbitrary // parent directories; a marker planted there must not steer // write-back to an attacker's host. if (info && info.host && info.user && info.remotePath && dirname(dir) === join(homedir(), ".dsh", "remote-workspaces")) return { root: dir, info: info };`], ['patch 11: sync-down refuses escaping links before the tree lands', ` const pipe = await runTarPipe(sshH, tarH, o.timeoutMs, { label: "同步", a: "ssh", b: "tar" }, signal); if (!pipe.ok) { try { await rm(tmpDir, { recursive: true, force: true }); } catch (e) {} return { ok: false, error: pipe.error + "(本地镜像未改动,已丢弃本次拉取的内容)" }; }`, ` const pipe = await runTarPipe(sshH, tarH, o.timeoutMs, { label: "同步", a: "ssh", b: "tar" }, signal); if (!pipe.ok) { try { await rm(tmpDir, { recursive: true, force: true }); } catch (e) {} return { ok: false, error: pipe.error + "(本地镜像未改动,已丢弃本次拉取的内容)" }; } // [workspace-groups-remote patch] The tar stream is remote-controlled: // refuse the sync when the extracted tree holds a symlink pointing // outside the extraction dir — the copy/swap below would follow it and // land content outside the mirror. const escapee = findEscapingLink(tmpDir); if (escapee) { try { await rm(tmpDir, { recursive: true, force: true }); } catch (e) {} return { ok: false, error: "已拒绝同步:远端内容包含指向镜像之外的符号链接(" + escapee + "),本地镜像未改动。" }; }`], ['patch 3d: wrapper remotePath base64-encoded', ' " const expanded = remotePath === \'~\' ? \'$HOME\' : (remotePath.indexOf(\'~/\') === 0 ? \'$HOME/\' + remotePath.slice(2) : remotePath);",', ` " // [workspace-groups-remote patch] The path reaches the remote", " // shell base64-encoded and is decoded there: its content is data,", " // never shell syntax, so quotes, $() and backticks in a directory", " // name can no longer break out. (~ still expands remotely.)", " const b64 = (s) => Buffer.from(String(s), 'utf8').toString('base64');", " const expanded = remotePath === '~' ? '$HOME' : (remotePath.indexOf('~/') === 0 ? '$HOME/$(printf %s \\\\'' + b64(remotePath.slice(2)) + '\\\\' | base64 -d)' : '$(printf %s \\\\'' + b64(remotePath) + '\\\\' | base64 -d)');",`], ['patch 12: reusing a record keeps its existing title', ' const lastSeg = String(a.remotePath).replace(/\\/+$/, "").split("/").pop();\n const title = a.title || (lastSeg && lastSeg !== "~" ? lastSeg : (p.name + ":" + a.remotePath));', ` // [workspace-groups-remote patch] Reuse keeps the user's existing // title; only a new record (or an explicit a.title) derives one from // the path. Otherwise "reuse" could silently rename a custom workspace. const lastSeg = String(a.remotePath).replace(/\\/+$/, "").split("/").pop(); const title = a.title || (existing && existing.title) || (lastSeg && lastSeg !== "~" ? lastSeg : (p.name + ":" + a.remotePath));`], ] function countOccurrences(text, needle) { let count = 0 let at = text.indexOf(needle) while (at !== -1) { count += 1; at = text.indexOf(needle, at + needle.length) } return count } function applyPatch(source) { if (countOccurrences(source, RUNREMOTE_ANCHOR) !== 1) { throw new Error('patch-remote-ssh: runRemote anchor not found exactly once — upstream changed, re-check the patch') } if (countOccurrences(source, FIND_ANCHOR) !== 1) { throw new Error('patch-remote-ssh: createRemoteWorkspace reuse-lookup anchor not found exactly once — upstream changed, re-check the patch') } let out = source.replace(RUNREMOTE_ANCHOR, HELPERS + SELF_CHECK + RUNREMOTE_ANCHOR) out = out.replace(FIND_ANCHOR, FIND_REPLACEMENT) for (const [label, anchor, replacement] of TRANSFORMS) { if (countOccurrences(out, anchor) !== 1) { throw new Error('patch-remote-ssh: anchor for ' + label + ' not found exactly once — upstream changed, re-check the patch') } out = out.replace(anchor, replacement) } // Post-conditions: the vulnerable code forms must be gone, the fixed // forms present. (A historical comment mentioning StrictHostKeyChecking=no // remains in the source; only the executable code form is asserted here.) const gone = ['head.concat(opts, [target])', '["sshpass", "-p"', "'StrictHostKeyChecking=no', '-o', 'ExitOnForwardFailure=no'", 'lightRemotePath(w.remotePath) === lightRemotePath(a.remotePath)'] for (const bad of gone) { if (out.includes(bad)) throw new Error('patch-remote-ssh: vulnerable form still present after patching: ' + bad) } const present = ['resolveRemoteCanonical', 'targetResolved.ok', '无法确认远端路径是否重复', 'existing && existing.title', 'head.concat(opts, ["--", target])', '"sshpass", "-e"', 'StrictHostKeyChecking=accept-new', 'inMirrorRoot', 'base64 -d', 'foldedParts', '写回护栏无法确认,本次不推送', 'upstream internals changed (runRemote / shellQuotePath not found)', 'findEscapingLink', 'renameSync(tmpFile, file)', "%s %Y %N", 'startsWith(prev + ".")', 'foldCase', 'dirname(dir) === join(homedir()'] for (const good of present) { if (!out.includes(good)) throw new Error('patch-remote-ssh: expected patched form missing: ' + good) } return out } export function writePatchedRemoteSsh(root) { const sourcePath = join(root, 'vendor/dsh-remote-ssh/lib/index.js') const targetPath = join(root, 'lib/remote-ssh/index.js') const patched = applyPatch(readFileSync(sourcePath, 'utf8')) mkdirSync(dirname(targetPath), { recursive: true }) writeFileSync(targetPath, patched) return targetPath } const invokedDirectly = process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1] if (invokedDirectly) { const root = join(dirname(fileURLToPath(import.meta.url)), '..') const target = writePatchedRemoteSsh(root) console.log('patch-remote-ssh: wrote ' + target) }