@zicolasjac-ai/remote-readonly-ssh 1.1.7 → 1.2.1

package/README.md

@@ -7,8 +7,9 @@
 ## 为什么需要它
 
 - **技术强制只读**：命令前缀白名单 + 禁止模式 + 参数防注入 + 目标主机白名单，多层校验。
+- **主机密钥防中间人**：TOFU 校验——首次连接自动记录堡垒机公钥指纹（`~/.rrs/known_hosts.json`），之后每次连接比对，不一致直接拒绝。
 - **审计留痕**：每次调用（含被拒绝的记录）写入本地审计日志，可随时审查。
-- **零依赖**：只依赖系统自带 `ssh` 客户端，无 npm 依赖树。
+- **极简依赖**：连接层用纯 JS 的 `ssh2`（无原生编译），认证组支持 **SSH 私钥 / 密码** 两种模式，可按 IP 分组配置（N 台主机共用一组凭据），跨平台行为一致。
 - **AI Agent 友好**：附带 SKILL.md 可一键安装到 opencode / Claude / Cursor / Windsurf / Codex / OpenHands 等 AI 助手的 skills 目录。
 
 ## 开始使用
@@ -22,8 +23,8 @@ npx -y @zicolasjac-ai/remote-readonly-ssh@latest init
 npx 会自动拉取最新版本、进入初始化向导，依次询问：
 
 1. 是否覆盖已有 `~/.rrs/config.json`（首次安装跳过此步）
-2. 堡垒机主机 / 端口 / 用户名 / SSH 私钥路径
-3. 目标主机白名单（每行 `ip=堡垒机搜索关键字`）
+2. **认证组**：堡垒机主机 / 端口 / 用户名 / 认证模式（SSH 密钥或密码）/ 凭据；可配置多个认证组
+3. 目标主机白名单（每行 `ip=堡垒机搜索关键字`），并为每台主机指定归属的认证组（多台主机可共用同一组）
 4. 是否把 SKILL.md 安装到 opencode / Claude Code / Cursor 等 AI 助手
 
 向导结束后 `~/.rrs/config.json` 已就位、`~/.rrs/audit.log` 已建好、AI skill 已分发。直接试跑：
@@ -46,7 +47,7 @@ rrs sys-info --json     # 直接用 rrs 前缀
 >
 > 从旧包名 `remote-readonly-ssh`（v1.0.0）升级的用户，请先 `npm uninstall -g remote-readonly-ssh` 再安装，否则会报 `EEXIST: file already exists`。
 
-要求 Node.js >= 18，系统已装 OpenSSH 客户端（Windows 10+ / Linux / macOS 自带）。
+要求 Node.js >= 18（连接层走内置 `ssh2`，无需系统 OpenSSH 客户端）。
 
 ## 用法
 
@@ -74,16 +75,18 @@ rrs <tool> [arg] [--host <ip>] [--config <file>] [--json]
 
 | 键 | 说明 |
 |-----|------|
-| `jump_server` | 堡垒机地址 / 端口 / 用户名 |
-| `ssh_options` | 附加 ssh 参数（默认 `StrictHostKeyChecking=no`、兼容旧堡垒机的 ssh-rsa 算法开关，可按需调整） |
+| `auth_profiles` | **认证组**（可多个）：`{组名: {host, port, username, auth}}`。`auth.mode` 支持 `key`（`private_key_path` 必填，可选 `private_key_passphrase`）与 `password`（`password` 必填）。`list-tools` 只显示模式与主机，不显示任何凭据 |
+| `target_hosts` | 目标主机白名单 `{ip: {profile, keyword?}}`：`profile` 引用认证组名，`keyword` 为堡垒机资产搜索关键字（缺省用 IP）。**多台主机可共用同一认证组（N:1）** |
 | `audit` | `enabled`（默认 true，关闭则不留痕）与 `include_output`（默认 false，true 时把命令输出摘要写入审计日志） |
-| `private_key_path` | SSH 私钥路径（Windows 建议放 `~/.ssh/locked/` 收紧 ACL；Linux/Mac 用 `chmod 600`） |
-| `target_hosts` | 允许访问的目标主机白名单 `{ip: 堡垒机搜索关键字}` |
 | `allowed_version_bins` | 允许执行 `-v/-V` 的二进制白名单 |
 | `allowed_command_prefixes` | 只读命令前缀白名单（cat/ls/grep/ps/ss/tail...） |
 | `allowed_path_prefixes` | 允许读取的路径前缀 |
 | `blocked_paths` | 敏感路径黑名单（shadow/passwd/密钥/家目录） |
 
+> **凭据安全提示**：密码为明文存放于本机 `config.json`（与私钥文件同级信任，仅本机可读）。Windows 建议收紧 ACL，Linux/macOS 建议 `chmod 600 ~/.rrs/config.json`。
+>
+> **主机密钥校验**：首次连接堡垒机时自动记录其公钥指纹到 `~/.rrs/known_hosts.json`；此后密钥变化一律拒绝连接（防中间人）。若堡垒机确实已更换，删除该文件中对应条目重试即可重新记录。`init` 向导中密码输入**静音不回显**。
+
 审计日志：`~/.rrs/audit.log`
 
 ## Agent Skills
@@ -132,6 +135,8 @@ npm test          # 运行单元测试（node --test）
 - **防绕过加固**：路径 `..` 穿越规范化、通配符 glob（`/etc/*/shadow`）、反斜杠转义、命令替换（`$()`、反引号）、变量展开（`$HOME`）、波浪号（`~`）、分隔符（`;` `&` `&&`）、换行注入等攻击面全部封堵；`hostname <name>`、`date -s` 等状态变更命令拒绝。
 - **参数防注入**：`proc`/`ports`/`bin-version` 参数做严格字符集校验。
 - **主机白名单**：未登记 IP 一律拒绝。
+- **主机密钥 TOFU**：堡垒机公钥指纹首见记录（`~/.rrs/known_hosts.json`）、每次连接比对，变化即拒绝（防中间人窃取凭据/会话）；连接错误消息中的凭据类内容自动脱敏。
+- **凭据不落命令行**：认证走 ssh2 库内存参数，密码/私钥不出现在进程参数与环境变量中；审计日志只记命令，不含凭据。
 - **无写原语**：工具集中不存在任何写操作路径；写操作由人工执行，本工具只读。
 
 **已知边界**（设计取舍）：

package/bin/rrs.js

@@ -3,7 +3,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { loadConf, configDir, audit } = require("../src/config");
+const { loadConf, configDir, audit, validateConfig } = require("../src/config");
 const { JumpShell, cleanAnsi } = require("../src/jumpshell");
 const {
   validateCmd, validatePath, validateHost, validateArg, validateBin,
@@ -126,7 +126,10 @@ function runSetup(opts) {
 
 function initConfig() {
   if (process.stdin.isTTY && process.stdout.isTTY) {
-    return initWizard.runInteractive();
+    return initWizard.runInteractive().catch((e) => {
+      console.error(`[init] ${e.message}`);
+      process.exit(1);
+    });
   }
   const dir = configDir();
   const dest = path.join(dir, "config.json");
@@ -137,7 +140,7 @@ function initConfig() {
   const tpl = fs.readFileSync(path.join(PACKAGE_ROOT, "config.example.json"), "utf8");
   fs.writeFileSync(dest, tpl, "utf8");
   console.log(`已生成配置模板: ${dest}`);
-  console.log("请填写 jump_server（跳板机）、private_key_path（私钥）、target_hosts（目标主机）后使用。");
+  console.log("请填写 auth_profiles（认证组：SSH 私钥或密码）、target_hosts（目标主机）后使用。");
 }
 
 function buildCmds(tool, arg, conf) {
@@ -180,7 +183,9 @@ function listTools(conf) {
     "exec-only <cmd>": "通用只读命令（白名单校验）",
   };
   for (const [k, v] of Object.entries(tools)) console.log(`  ${k.padEnd(20)} ${v}`);
-  console.log(`\n允许主机: ${Object.keys(conf.target_hosts || {}).join(", ")}`);
+  const profiles = conf.auth_profiles || {};
+  console.log(`\n认证组: ${Object.entries(profiles).map(([id, p]) => `${id}(${p.auth.mode}@${p.host})`).join(", ") || "(无)"}`);
+  console.log(`允许主机: ${Object.keys(conf.target_hosts || {}).join(", ")}`);
   console.log(`允许查版本: ${(conf.allowed_version_bins || []).join(", ")}`);
   console.log(`允许读路径前缀: ${(conf.allowed_path_prefixes || []).join(", ")}`);
   console.log(`配置文件: ${process.env.RRS_CONFIG || path.join(configDir(), "config.json")}`);
@@ -211,6 +216,13 @@ async function main() {
     process.exit(e.exitCode || 1);
   }
 
+  try {
+    validateConfig(conf);
+  } catch (e) {
+    emitResult(opts, { ok: false, error: e.message, kind: "错误" });
+    process.exit(e.exitCode || 1);
+  }
+
   if (opts.tool === "list-tools") { listTools(conf); return; }
 
   let host, cmds;
@@ -225,7 +237,7 @@ async function main() {
 
   const shell = new JumpShell(conf, host);
   try {
-    shell.connect();
+    await shell.connect();
     await shell.login();
     const out = await shell.runCmds(cmds);
     const cleaned = cleanAnsi(out);

package/config.example.json

@@ -1,23 +1,33 @@
 {
-  "jump_server": {
-    "host": "YOUR_BASTION_IP",
-    "port": 2222,
-    "username": "YOUR_USERNAME"
+  "auth_profiles": {
+    "profile_a": {
+      "host": "YOUR_BASTION_IP",
+      "port": 2222,
+      "username": "YOUR_USERNAME",
+      "auth": {
+        "mode": "key",
+        "private_key_path": "C:\\Users\\YOURNAME\\.ssh\\id_rsa",
+        "private_key_passphrase": null
+      }
+    },
+    "profile_b": {
+      "host": "YOUR_BASTION_IP_2",
+      "port": 2222,
+      "username": "YOUR_USERNAME_2",
+      "auth": {
+        "mode": "password",
+        "password": "YOUR_PASSWORD"
+      }
+    }
+  },
+  "target_hosts": {
+    "10.0.0.1": { "profile": "profile_a", "keyword": "10.0.0" },
+    "10.0.0.2": { "profile": "profile_a", "keyword": "10.0.0" }
   },
-  "ssh_options": [
-    "-o", "StrictHostKeyChecking=no",
-    "-o", "HostKeyAlgorithms=+ssh-rsa",
-    "-o", "PubkeyAcceptedAlgorithms=+ssh-rsa"
-  ],
   "audit": {
     "enabled": true,
     "include_output": false
   },
-  "private_key_path": "C:\\Users\\YOURNAME\\.ssh\\id_rsa",
-  "target_hosts": {
-    "10.0.0.1": "10.0.0",
-    "10.0.0.2": "10.0.0"
-  },
   "allowed_version_bins": [
     "/usr/local/nginx/sbin/nginx",
     "nginx",
@@ -71,4 +81,4 @@
     "/home/",
     "/etc/ssh/"
   ]
-}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zicolasjac-ai/remote-readonly-ssh",
-  "version": "1.1.7",
-  "description": "只读 SSH 运维 CLI 与 Agent Skill：通过 JumpServer 堡垒机白名单强制执行只读查询；附 SKILL.md 让 opencode / Claude Code / Cursor 等 AI 助手自动发现并正确调用。",
+  "version": "1.2.1",
+  "description": "只读 SSH 运维 CLI 与 Agent Skill：通过 JumpServer 堡垒机白名单强制执行只读查询；认证组支持 SSH 私钥/密码两种模式与按 IP 分组；附 SKILL.md 让 opencode / Claude Code / Cursor 等 AI 助手自动发现并正确调用。",
   "license": "MIT",
   "bin": {
     "rrs": "bin/rrs.js"
@@ -33,7 +33,9 @@
     "claude",
     "ai"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "ssh2": "^1.17.0"
+  },
   "scripts": {
     "test": "node --test",
     "postinstall": "node bin/postinstall.js",

package/skills/remote-readonly-ssh/SKILL.md

@@ -32,7 +32,7 @@ metadata:
 ```bash
 npm install -g @zicolasjac-ai/remote-readonly-ssh
 rrs init          # 生成配置模板 ~/.rrs/config.json
-# 编辑配置: jump_server / private_key_path / target_hosts
+# 编辑配置: auth_profiles（认证组，key/password 两种模式，可多个）/ target_hosts（IP → 认证组+搜索关键字，多 IP 可共用一组）
 rrs setup skills  # 把本 skill 安装到 opencode / claude / agents 等目录
 ```
 

package/src/config.js

@@ -33,6 +33,76 @@ function loadConf(confPath) {
   }
 }
 
+function cfgError(msg) {
+  const err = new Error(`配置错误: ${msg}`);
+  err.exitCode = 3;
+  return err;
+}
+
+/**
+ * 校验配置 schema（v2：auth_profiles + target_hosts 分组引用）。
+ * - auth_profiles: 认证组；auth.mode ∈ {key, password}
+ *   - key 模式：private_key_path 必填且文件必须存在；private_key_passphrase 可选
+ *   - password 模式：password 必填非空
+ * - target_hosts: {ip: {profile, keyword?}}，profile 必须引用已存在的认证组
+ */
+function validateConfig(conf) {
+  const errors = [];
+  const profiles = conf.auth_profiles;
+
+  if (!profiles || typeof profiles !== "object" || Array.isArray(profiles) || Object.keys(profiles).length === 0) {
+    errors.push("缺少 auth_profiles（认证组，见 config.example.json）");
+  } else {
+    for (const [id, p] of Object.entries(profiles)) {
+      if (!p || typeof p !== "object" || Array.isArray(p)) {
+        errors.push(`auth_profiles[${id}] 必须是对象 {host, port, username, auth}`) ;
+        continue;
+      }
+      if (!p.host || typeof p.host !== "string") errors.push(`认证组 [${id}] 缺少 host`);
+      if (!p.username || typeof p.username !== "string") errors.push(`认证组 [${id}] 缺少 username`);
+      if (p.port !== undefined && (!Number.isInteger(p.port) || p.port < 1 || p.port > 65535)) {
+        errors.push(`认证组 [${id}] port 必须是 1-65535 的整数，当前: ${p.port}`);
+      }
+      const auth = p.auth;
+      if (!auth || typeof auth !== "object" || Array.isArray(auth)) {
+        errors.push(`认证组 [${id}] 缺少 auth {mode, ...}`);
+        continue;
+      }
+      if (auth.mode !== "key" && auth.mode !== "password") {
+        errors.push(`认证组 [${id}] auth.mode 必须是 "key" 或 "password"，当前: ${auth.mode}`);
+      } else if (auth.mode === "key") {
+        if (!auth.private_key_path || typeof auth.private_key_path !== "string") {
+          errors.push(`认证组 [${id}] key 模式缺少 private_key_path`);
+        } else if (!fs.existsSync(auth.private_key_path)) {
+          errors.push(`认证组 [${id}] 私钥文件不存在: ${auth.private_key_path}`);
+        }
+      } else if (typeof auth.password !== "string" || !auth.password) {
+        errors.push(`认证组 [${id}] password 模式缺少 password`);
+      }
+    }
+  }
+
+  const hosts = conf.target_hosts;
+  if (!hosts || typeof hosts !== "object" || Array.isArray(hosts) || Object.keys(hosts).length === 0) {
+    errors.push("缺少 target_hosts（目标主机白名单）");
+  } else {
+    for (const [ip, entry] of Object.entries(hosts)) {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        errors.push(`target_hosts[${ip}] 必须是对象 {profile, keyword?}`);
+        continue;
+      }
+      if (!entry.profile || typeof entry.profile !== "string") {
+        errors.push(`target_hosts[${ip}] 缺少 profile（认证组名）`);
+      } else if (!profiles || !profiles[entry.profile]) {
+        errors.push(`target_hosts[${ip}] 引用不存在的认证组 [${entry.profile}]`);
+      }
+    }
+  }
+
+  if (errors.length) throw cfgError(errors.join("；"));
+  return true;
+}
+
 const TOOL_PURPOSE = {
   "sys-info": "系统信息巡检",
   "proc": "进程状态巡检",
@@ -103,4 +173,4 @@ function audit(conf, tool, host, cmds, ok, note, output, confDir) {
   }
 }
 
-module.exports = { configDir, configFile, auditFile, loadConf, audit };
+module.exports = { configDir, configFile, auditFile, loadConf, audit, validateConfig };

package/src/init.js

@@ -3,6 +3,7 @@
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const { Writable } = require("node:stream");
 const readline = require("node:readline/promises");
 const setupSkill = require("./setup");
 
@@ -40,24 +41,88 @@ function parseTargets(text) {
 
 function applyAnswers(cfg, answers) {
   const a = answers || {};
-  if (a.jumpHost) cfg.jump_server.host = a.jumpHost;
-  if (a.jumpPort) cfg.jump_server.port = Number(a.jumpPort) || cfg.jump_server.port;
-  if (a.jumpUser) cfg.jump_server.username = a.jumpUser;
-  if (a.privateKeyPath) cfg.private_key_path = a.privateKeyPath;
-  if (a.targetHosts && Object.keys(a.targetHosts).length) cfg.target_hosts = a.targetHosts;
+  if (a.authProfiles && a.authProfiles.length) {
+    const profiles = {};
+    for (const p of a.authProfiles) {
+      const auth = { mode: p.mode };
+      if (p.mode === "password") {
+        auth.password = p.password;
+      } else {
+        auth.private_key_path = p.privateKeyPath;
+        if (p.passphrase) auth.private_key_passphrase = p.passphrase;
+      }
+      profiles[p.name] = {
+        host: p.host,
+        port: Number(p.port) || 22,
+        username: p.username,
+        auth,
+      };
+    }
+    cfg.auth_profiles = profiles;
+  }
+  if (a.targets && Object.keys(a.targets).length) {
+    const hosts = {};
+    for (const [ip, kw] of Object.entries(a.targets)) {
+      hosts[ip] = {
+        profile: (a.targetProfileMap && a.targetProfileMap[ip]) || "",
+        keyword: kw,
+      };
+    }
+    cfg.target_hosts = hosts;
+  }
   return cfg;
 }
 
 function defaultAnswersFor(cfg) {
+  const first = Object.values(cfg.auth_profiles || {})[0] || {};
   return {
-    jumpHost: cfg.jump_server && cfg.jump_server.host ? "" : "",
-    jumpPort: cfg.jump_server && cfg.jump_server.port ? String(cfg.jump_server.port) : "22",
-    jumpUser: cfg.jump_server && cfg.jump_server.username ? cfg.jump_server.username : "",
-    privateKeyPath: cfg.private_key_path && !cfg.private_key_path.includes("YOURNAME") ? cfg.private_key_path : "",
+    authProfiles: cfg.auth_profiles || {},
     targetHosts: cfg.target_hosts || {},
+    defaultProfile: Object.keys(cfg.auth_profiles || {})[0] || "",
+    defaultHost: (first.host && !first.host.includes("YOUR_")) ? first.host : "",
+    defaultKey: (first.auth && first.auth.private_key_path && !first.auth.private_key_path.includes("YOURNAME")) ? first.auth.private_key_path : "",
   };
 }
 
+/**
+ * 静音输入（TTY 下不回显，防肩窥）。
+ * 原理：临时把 readline 的 output 替换为吞字节流（屏蔽 readline 的按键回显），
+ * 自行逐字节收集（支持退格）；结束恢复原 output。
+ * 非标准环境（测试 mock / 管道，无 TTY）回退为普通 question（明文回显）。
+ */
+function askSecret(rl, q) {
+  const input = rl.input;
+  const output = rl.output;
+  if (!input || !output || input.isTTY !== true || typeof input.setRawMode !== "function") {
+    return Promise.resolve(rl.question(`${q}: `));
+  }
+  return new Promise((resolve, reject) => {
+    const silent = new Writable({
+      write(_chunk, _enc, cb) { cb(); },
+    });
+    rl.output = silent;
+    const wasRaw = input.isRaw;
+    input.setRawMode(true);
+    output.write(`${q}: `);
+    let buf = "";
+    const finish = (fn) => {
+      input.removeListener("data", onData);
+      try { input.setRawMode(wasRaw); } catch (_) {}
+      rl.output = output;
+      output.write("\n");
+      fn();
+    };
+    const onData = (ch) => {
+      const s = ch.toString("utf8");
+      if (s === "\r" || s === "\n") return finish(() => resolve(buf));
+      if (s === "\u0003") return finish(() => reject(new Error("已取消输入")));
+      if (s === "\u007f" || s === "\b") { buf = buf.slice(0, -1); return; }
+      if (s >= " ") buf += s;
+    };
+    input.on("data", onData);
+  });
+}
+
 async function collectAnswers(rl, cfg, prompt) {
   const ask = async (q, def) => {
     const label = def ? `${q} [${def}]` : q;
@@ -65,27 +130,69 @@ async function collectAnswers(rl, cfg, prompt) {
     return ans || def || "";
   };
   const usePrompt = prompt && typeof prompt === "object";
-  const ans = {};
-  ans.jumpHost = usePrompt && prompt.jumpHost
-    ? await prompt.jumpHost(ask, cfg)
-    : await ask("堡垒机主机 IP / 域名", "");
-  if (!ans.jumpHost) {
-    throw new Error("跳过：未填写堡垒机主机。请稍后编辑 " + path.join(os.homedir(), ".rrs", "config.json"));
+  const def = defaultAnswersFor(cfg);
+
+  // 1. 认证组（可多个；多个主机可共用同一组，实现 N:1 分组）
+  let authProfiles = [];
+  if (usePrompt && prompt.authProfiles) {
+    authProfiles = await prompt.authProfiles(ask, cfg);
+  } else {
+    while (true) {
+      const name = await ask("认证组名称（可多个，至少一个；多个主机可共用同一组；留空结束）", "");
+      if (!name) {
+        if (authProfiles.length === 0) {
+          throw new Error("跳过：未填写认证组。请稍后编辑 " + path.join(os.homedir(), ".rrs", "config.json"));
+        }
+        break;
+      }
+      if (authProfiles.some((p) => p.name === name)) {
+        process.stdout.write(`  认证组 [${name}] 已存在，请换一个名称\n`);
+        continue;
+      }
+      const host = await ask("  堡垒机主机 IP/域名", "");
+      if (!host) {
+        throw new Error("跳过：未填写堡垒机主机。请稍后编辑 " + path.join(os.homedir(), ".rrs", "config.json"));
+      }
+      const port = await ask("  堡垒机端口", "22");
+      const username = await ask("  堡垒机用户名", "");
+      const modeAns = await ask("  认证模式 (1=SSH密钥 2=密码)", "1");
+      const mode = modeAns === "2" ? "password" : "key";
+      let privateKeyPath = "";
+      let passphrase = "";
+      let password = "";
+      if (mode === "key") {
+        privateKeyPath = await ask("  SSH 私钥绝对路径", def.defaultKey || path.join(os.homedir(), ".ssh", "id_rsa"));
+        passphrase = (await askSecret(rl, "  私钥口令（无则留空）")).trim();
+      } else {
+        password = (await askSecret(rl, "  登录密码")).trim();
+        if (!password) {
+          throw new Error("跳过：未填写登录密码。请稍后编辑 " + path.join(os.homedir(), ".rrs", "config.json"));
+        }
+      }
+      authProfiles.push({ name, host, port, username, mode, privateKeyPath, passphrase, password });
+    }
   }
-  ans.jumpPort = usePrompt && prompt.jumpPort
-    ? await prompt.jumpPort(ask, cfg)
-    : await ask("堡垒机端口", "22");
-  ans.jumpUser = usePrompt && prompt.jumpUser
-    ? await prompt.jumpUser(ask, cfg)
-    : await ask("堡垒机用户名", "");
-  ans.privateKeyPath = usePrompt && prompt.privateKeyPath
-    ? await prompt.privateKeyPath(ask, cfg)
-    : await ask("SSH 私钥绝对路径", path.join(os.homedir(), ".ssh", "id_rsa"));
+
+  // 2. 目标主机白名单（ip=堡垒机搜索关键字）
   const targetText = usePrompt && prompt.targetHosts
     ? await prompt.targetHosts(ask, cfg)
     : await ask("目标主机（每行 ip=堡垒机搜索关键字，空行结束）", "");
-  ans.targetHosts = parseTargets(targetText);
-  return ans;
+  const targets = parseTargets(targetText);
+
+  // 3. 每台主机归属的认证组（默认第一个组）
+  const defaultProfile = authProfiles[0] && authProfiles[0].name;
+  if (Object.keys(targets).length && !defaultProfile) {
+    throw new Error("配置错误: 未配置认证组，无法关联目标主机");
+  }
+  const targetProfileMap = {};
+  for (const ip of Object.keys(targets)) {
+    const p = usePrompt && prompt.targetProfile
+      ? await prompt.targetProfile(ask, cfg, ip)
+      : await ask(`  主机 ${ip} 使用的认证组`, defaultProfile);
+    targetProfileMap[ip] = p || defaultProfile;
+  }
+
+  return { authProfiles, targets, targetProfileMap };
 }
 
 async function runInteractive({ input = process.stdin, output = process.stdout, packageRoot = PACKAGE_ROOT, prompt, installSkills = true, rlFactory } = {}) {

package/src/jumpshell.js

@@ -1,6 +1,10 @@
 "use strict";
 
-const { spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { Client } = require("ssh2");
+const { configDir } = require("./config");
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
@@ -17,46 +21,187 @@ const ERR_PATTERNS = [
   /no route to host/i,
 ];
 
-const DEFAULT_SSH_OPTIONS = [
-  "-o", "StrictHostKeyChecking=no",
-  "-o", "HostKeyAlgorithms=+ssh-rsa",
-  "-o", "PubkeyAcceptedAlgorithms=+ssh-rsa",
-];
+// ssh2 默认算法集已兼容 JumpServer 常见旧算法（ssh-rsa hostkey、diffie-hellman-group14-sha1 等），
+// 客户端列表强算法优先，无需额外放宽。
+const CONNECT_OPTIONS = {
+  readyTimeout: 20000,
+  keepaliveInterval: 10000,
+};
+
+// ==== 主机密钥 TOFU（trust-on-first-use）====
+// 等价并强于原 ssh -o StrictHostKeyChecking=no：首次连接记录堡垒机公钥指纹到
+// ~/.rrs/known_hosts.json，之后每次连接比对，不一致则拒绝（防中间人长期冒充）。
+
+function knownHostsPath(dir) {
+  return path.join(dir || configDir(), "known_hosts.json");
+}
+
+function loadKnownHosts(dir) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(knownHostsPath(dir), "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (_) {
+    return {};
+  }
+}
+
+function saveKnownHosts(store, dir) {
+  const target = knownHostsPath(dir);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, JSON.stringify(store, null, 2), "utf8");
+}
+
+function hostKeyFingerprint(hostkey) {
+  return "sha256:" + crypto.createHash("sha256").update(hostkey).digest("base64");
+}
+
+/**
+ * 纯函数：比对主机密钥。首见返回 isNew=true（调用方负责持久化），
+ * 已知且匹配返回 ok=true；已知但不匹配返回 ok=false（应拒绝连接）。
+ */
+function checkHostKey(store, endpointId, hostkey) {
+  const fp = hostKeyFingerprint(hostkey);
+  if (!store[endpointId]) return { ok: true, fp, isNew: true };
+  return { ok: store[endpointId] === fp, fp, isNew: false, known: store[endpointId] };
+}
 
 /**
- * 通过系统 ssh 驱动 JumpServer 堡垒机菜单，登录目标资产并执行命令。
+ * 从配置解析某目标主机所属的认证组（auth_profiles 条目）。
+ * target_hosts[host] = { profile, keyword }；keyword 缺省回退为 host 本身。
+ */
+function resolveHostEntry(conf, host) {
+  const entry = conf.target_hosts && conf.target_hosts[host];
+  if (!entry) {
+    throw new Error(`配置错误: 目标主机 [${host}] 未在 target_hosts 注册`);
+  }
+  if (typeof entry !== "object" || Array.isArray(entry)) {
+    throw new Error(`配置错误: target_hosts[${host}] 必须是对象 {profile, keyword}`);
+  }
+  return entry;
+}
+
+function resolveProfile(conf, host) {
+  const entry = resolveHostEntry(conf, host);
+  const profile = conf.auth_profiles && conf.auth_profiles[entry.profile];
+  if (!profile) {
+    throw new Error(`配置错误: 目标主机 [${host}] 引用的认证组 [${entry.profile}] 不存在（auth_profiles）`);
+  }
+  return profile;
+}
+
+/**
+ * 把 ssh2 连接错误映射为友好提示；原始消息中的密码类内容一律脱敏，不泄露凭据。
+ */
+function mapConnError(e) {
+  const msg = String((e && e.message) || e).replace(
+    /(password|passwd)[=:\s][^\s,;]+/gi,
+    "$1=***"
+  );
+  if (/host key verification|host denied/i.test(msg)) {
+    return new Error(
+      "堡垒机主机密钥与首次记录不一致（已拒绝，防中间人）。" +
+      "若堡垒机确实已更换，请删除 ~/.rrs/known_hosts.json 中对应条目后重试"
+    );
+  }
+  if (/authentication|permission denied/i.test(msg)) {
+    return new Error(`SSH 认证失败: ${msg}（请检查 auth_profiles 的账号/密码/私钥）`);
+  }
+  if (/connect/i.test(msg)) {
+    return new Error(`SSH 连接失败: ${msg}`);
+  }
+  return new Error(`SSH 错误: ${msg}`);
+}
+
+/**
+ * 通过 ssh2 连接 JumpServer 堡垒机菜单，登录目标资产并执行命令。
  * 仅负责"连接与收发"，命令校验在调用方（whitelist.js）完成。
  */
 class JumpShell {
-  constructor(conf, host) {
-    this.searchKeyword = conf.target_hosts[host];
+  constructor(conf, host, opts = {}) {
     this.host = host;
     this.conf = conf;
-    this.proc = null;
+    this.entry = resolveHostEntry(conf, host);
+    this.profile = resolveProfile(conf, host);
+    this.searchKeyword = this.entry.keyword || host;
+    this.knownHostsDir = opts.knownHostsDir; // 测试注入用；缺省 ~/.rrs
+    this.conn = null;
+    this.stream = null;
     this.out = "";
     this.err = "";
     this.terminated = false;
   }
 
-  connect() {
-    const js = this.conf.jump_server;
-    const opts = this.conf.ssh_options && this.conf.ssh_options.length
-      ? this.conf.ssh_options
-      : DEFAULT_SSH_OPTIONS;
-    const args = [
-      "-i", this.conf.private_key_path,
-      "-p", String(js.port),
-      ...opts,
-      "-tt", `${js.username}@${js.host}`,
-    ];
-    this.proc = spawn("ssh", args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
-    this.proc.stdout.on("data", (d) => { this.out += d.toString("utf8"); });
-    this.proc.stderr.on("data", (d) => { this.err += d.toString("utf8"); });
+  /** 建立 ssh2 连接并打开伪终端；返回 Promise。 */
+  connect(timeoutSecs = 20) {
+    const p = this.profile;
+    const cfg = {
+      host: p.host,
+      port: p.port || 22,
+      username: p.username,
+      ...CONNECT_OPTIONS,
+    };
+    if (p.auth.mode === "password") {
+      cfg.password = p.auth.password;
+      // 兼容强制 keyboard-interactive 的堡垒机：用同一密码自动应答
+      cfg.tryKeyboard = true;
+    } else {
+      cfg.privateKey = fs.readFileSync(p.auth.private_key_path);
+      if (p.auth.private_key_passphrase) cfg.passphrase = p.auth.private_key_passphrase;
+    }
+
+    // 主机密钥 TOFU 校验：首见记录，不一致拒绝。
+    // ssh2 用户回调签名固定为 hostVerifier(key, verify)（key 为服务器公钥 Buffer）。
+    cfg.hostVerifier = (hostkey, verify) => {
+      try {
+        const store = loadKnownHosts(this.knownHostsDir);
+        const endpointId = `${cfg.host}:${cfg.port}`;
+        const r = checkHostKey(store, endpointId, hostkey);
+        if (r.isNew) {
+          store[endpointId] = r.fp;
+          saveKnownHosts(store, this.knownHostsDir);
+        }
+        verify(r.ok);
+      } catch (_) {
+        verify(false);
+      }
+    };
+
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+      this.conn = conn;
+      const fail = (e) => {
+        try { conn.end(); } catch (_) {}
+        reject(mapConnError(e));
+      };
+      conn.on("error", fail);
+      if (p.auth.mode === "password") {
+        conn.on("keyboard-interactive", (_name, _instr, _lang, _prompts, finish) => {
+          try { finish([cfg.password || ""]); } catch (_) {}
+        });
+      }
+      conn.on("ready", () => {
+        conn.shell({ term: "xterm", rows: 30, cols: 120 }, (err, stream) => {
+          if (err) return fail(err);
+          this.stream = stream;
+          stream.on("data", (d) => { this.out += d.toString("utf8"); });
+          stream.on("close", () => { this.terminated = true; });
+          if (stream.stderr) {
+            stream.stderr.on("data", (d) => { this.err += d.toString("utf8"); });
+          }
+          resolve();
+        });
+      });
+      try {
+        conn.connect(cfg);
+      } catch (e) {
+        fail(e);
+      }
+    });
   }
 
   send(s) {
-    if (this.proc && this.proc.stdin && !this.proc.stdin.destroyed) {
-      this.proc.stdin.write(s + "\r");
+    if (this.stream && !this.stream.destroyed) {
+      this.stream.write(s + "\r");
     }
   }
 
@@ -129,11 +274,8 @@ class JumpShell {
 
   close() {
     this.terminated = true;
-    try { this.send("exit"); } catch {}
-    try { if (this.proc && this.proc.stdin) this.proc.stdin.end(); } catch {}
-    setTimeout(() => {
-      try { if (this.proc) this.proc.kill(); } catch {}
-    }, 1000);
+    try { if (this.stream) this.stream.end(); } catch (_) {}
+    try { if (this.conn) this.conn.end(); } catch (_) {}
   }
 }
 
@@ -143,4 +285,8 @@ function cleanAnsi(t) {
     .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");           // CSI 序列（颜色/光标）
 }
 
-module.exports = { JumpShell, cleanAnsi, sleep, PROMPT_RE };
+module.exports = {
+  JumpShell, cleanAnsi, sleep, PROMPT_RE,
+  resolveHostEntry, resolveProfile, mapConnError,
+  knownHostsPath, loadKnownHosts, saveKnownHosts, hostKeyFingerprint, checkHostKey,
+};