ssh-licco 2.3.0__tar.gz → 2.4.0__tar.gz

{ssh_licco-2.3.0/ssh_licco.egg-info → ssh_licco-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 2.3.0
+Version: 2.4.0
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT
@@ -233,7 +233,6 @@ export SSH_EXTRA_ALLOWED_COMMANDS="git,pip,npm"
 
 - **[MCP_CONFIG_GUIDE.md](MCP_CONFIG_GUIDE.md)** - 完整配置指南，包含 5 种使用场景示例
 - **[SECURITY_CONFIG_GUIDE.md](SECURITY_CONFIG_GUIDE.md)** - 安全配置详解
-- **[docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)** - 生产加固四项方案（v2.1.0 新增）
 
 ### 🛡️ 硬拦截灾难性命令（v2.2.0 新增）
 
@@ -256,21 +255,6 @@ mv /path/to/junk /tmp/.trash_$(date +%s)/
 
 命中硬拦截时会输出 `WARNING` 审计日志（含 category 与命令），便于 SOC 监控。
 
-### 🏛️ 生产加固四项（v2.1.0 + v2.2.0 演进）
-
-SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
-
-| 加固点 | 开关 | 说明 |
-|--------|------|------|
-| 1. 运行账号最小权限 | `SSH_RUNTIME_GUARD=true` | 专用普通账号运行，拒绝 root/sudo 启动 |
-| 2. 密钥不落地磁盘 | `SSH_SECRET_PROVIDER_ENABLED=true` | 私钥从 KMS 临时拉取到内存，用完清零，不落盘 |
-| 3. 双层命令拦截 | `SSH_REMOTE_GUARD=true` + 远端 ForceCommand | 跳板机侧禁元字符 + 远端二次白名单校验 |
-| 4. 灾难性命令硬拦截（v2.2.0 新增） | 默认开启，不可关闭 | rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb、chmod -R 777/000 /、`> /dev/sd*` 等在 MCP 网关层被**无条件**拒绝；任何安全级别、`confirm_dangerous=true` 等均无法绕过 |
-
-> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` / `ssh_mcp/handlers/approval.py` 代码已在 v2.2.0 删除。
-
-完整方案见 [docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)。
-
 ---
 
 ## 🛠️ 可用工具（v2.2.0 维持 9 个；v2.1.0 曾增加的 3 个审批工具因流程闭环风险已下线）
@@ -278,7 +262,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | 工具 | 描述 | 核心能力 |
 |------|------|---------|
 | `ssh_connect` | 连接管理 | 自动读取环境变量/配置，支持密码+密钥认证，可保存配置，登录后自动执行命令 |
-| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式；v2.1.0 新增 `remote_guard`（双层拦截）参数；v2.2.0 起对灾难性命令（rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb 等）做**无条件硬拦截** |
+| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式；v2.2.0 起对灾难性命令（rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb 等）做**无条件硬拦截** |
 | `ssh_disconnect` | 会话管理 | 断开指定会话 OR 列出所有活跃会话 |
 | `ssh_file_transfer` | 文件传输 | 上传/下载/列表/写入/追加/删除/创建目录/查看元信息（8 种操作）；v2.1.3+ delete 操作新增 Windows/Unix 敏感路径拦截与路径遍历防护 |
 | `ssh_host` | 主机管理 | `action=list/add/remove` 增删查主机配置 |
@@ -453,6 +437,31 @@ localhost:5432 - accepting connections
 
 - **[MCP_CONFIG_GUIDE.md](MCP_CONFIG_GUIDE.md)** - 包含所有配置选项的详细说明
 
+### 🌐 完整环境变量速查（v2.3.0）
+
+> 下表所有变量均被代码读取。**注意**：
+> - `SSH_RATE_LIMIT` 是 **bool** 总开关（true/false），`SSH_RATE_LIMIT_MAX` 才是次数上限，两者分开配置
+> - 主机密钥检查（strict_host_key_checking）**不通过 env 配置**，请用 `ssh_connect` 工具参数或 `hosts.json`
+
+| 分类 | 变量 | 默认 | 说明 |
+|------|------|------|------|
+| **安全** | `SSH_SECURITY_LEVEL` | `balanced` | 安全级别：`strict` / `balanced` / `relaxed` |
+|  | `SSH_BASE_DIR` | `/home` | 路径校验基目录 |
+|  | `SSH_EXTRA_ALLOWED_COMMANDS` | (空) | 额外允许的命令（逗号分隔） |
+|  | `SSH_ALLOWED_COMMANDS_FILE` | (空) | 命令白名单 JSON 文件路径 |
+|  | `SSH_AUDIT_LOG_PATH` | (空) | 审计日志文件路径 |
+| **限流** | `SSH_RATE_LIMIT` | `true` | 限流总开关（bool） |
+|  | `SSH_RATE_LIMIT_MAX` | `30` | 限流次数上限 |
+|  | `SSH_RATE_LIMIT_WINDOW` | `60` | 限流窗口（秒） |
+| **硬拦截** | *(无 env)* | — | 灾难性命令硬拦截，零配置零绕过 |
+| **连接默认** | `SSH_HOST` / `SSH_PORT` / `SSH_USER` / `SSH_PASSWORD` | `127.0.0.1` / `22` / `root` / (空) | 单 host 模式默认连接参数 |
+|  | `SSH_TIMEOUT` | `60` | 连接超时（秒） |
+|  | `SSH_KEEPALIVE_INTERVAL` | `30` | keepalive 间隔（秒） |
+|  | `SSH_SESSION_TIMEOUT` | `7200` | 会话超时（秒） |
+|  | `SSH_CLIENT_TYPE` | `paramiko` | SSH 客户端实现：`paramiko` / `asyncssh` |
+|  | `SSH_FORCE_ENV_CONFIG` | `false` | 强制 env 配置覆盖 hosts.json |
+|  | `SSH_SUDO_PASSWORD` | (空) | sudo 密码，配合 `use_sudo=true` 走 `sudo -S` |
+
 ---
 
 ## ⚠️ 依赖版本兼容性

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/README.md

@@ -200,7 +200,6 @@ export SSH_EXTRA_ALLOWED_COMMANDS="git,pip,npm"
 
 - **[MCP_CONFIG_GUIDE.md](MCP_CONFIG_GUIDE.md)** - 完整配置指南，包含 5 种使用场景示例
 - **[SECURITY_CONFIG_GUIDE.md](SECURITY_CONFIG_GUIDE.md)** - 安全配置详解
-- **[docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)** - 生产加固四项方案（v2.1.0 新增）
 
 ### 🛡️ 硬拦截灾难性命令（v2.2.0 新增）
 
@@ -223,21 +222,6 @@ mv /path/to/junk /tmp/.trash_$(date +%s)/
 
 命中硬拦截时会输出 `WARNING` 审计日志（含 category 与命令），便于 SOC 监控。
 
-### 🏛️ 生产加固四项（v2.1.0 + v2.2.0 演进）
-
-SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
-
-| 加固点 | 开关 | 说明 |
-|--------|------|------|
-| 1. 运行账号最小权限 | `SSH_RUNTIME_GUARD=true` | 专用普通账号运行，拒绝 root/sudo 启动 |
-| 2. 密钥不落地磁盘 | `SSH_SECRET_PROVIDER_ENABLED=true` | 私钥从 KMS 临时拉取到内存，用完清零，不落盘 |
-| 3. 双层命令拦截 | `SSH_REMOTE_GUARD=true` + 远端 ForceCommand | 跳板机侧禁元字符 + 远端二次白名单校验 |
-| 4. 灾难性命令硬拦截（v2.2.0 新增） | 默认开启，不可关闭 | rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb、chmod -R 777/000 /、`> /dev/sd*` 等在 MCP 网关层被**无条件**拒绝；任何安全级别、`confirm_dangerous=true` 等均无法绕过 |
-
-> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` / `ssh_mcp/handlers/approval.py` 代码已在 v2.2.0 删除。
-
-完整方案见 [docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)。
-
 ---
 
 ## 🛠️ 可用工具（v2.2.0 维持 9 个；v2.1.0 曾增加的 3 个审批工具因流程闭环风险已下线）
@@ -245,7 +229,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | 工具 | 描述 | 核心能力 |
 |------|------|---------|
 | `ssh_connect` | 连接管理 | 自动读取环境变量/配置，支持密码+密钥认证，可保存配置，登录后自动执行命令 |
-| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式；v2.1.0 新增 `remote_guard`（双层拦截）参数；v2.2.0 起对灾难性命令（rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb 等）做**无条件硬拦截** |
+| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式；v2.2.0 起对灾难性命令（rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb 等）做**无条件硬拦截** |
 | `ssh_disconnect` | 会话管理 | 断开指定会话 OR 列出所有活跃会话 |
 | `ssh_file_transfer` | 文件传输 | 上传/下载/列表/写入/追加/删除/创建目录/查看元信息（8 种操作）；v2.1.3+ delete 操作新增 Windows/Unix 敏感路径拦截与路径遍历防护 |
 | `ssh_host` | 主机管理 | `action=list/add/remove` 增删查主机配置 |
@@ -420,6 +404,31 @@ localhost:5432 - accepting connections
 
 - **[MCP_CONFIG_GUIDE.md](MCP_CONFIG_GUIDE.md)** - 包含所有配置选项的详细说明
 
+### 🌐 完整环境变量速查（v2.3.0）
+
+> 下表所有变量均被代码读取。**注意**：
+> - `SSH_RATE_LIMIT` 是 **bool** 总开关（true/false），`SSH_RATE_LIMIT_MAX` 才是次数上限，两者分开配置
+> - 主机密钥检查（strict_host_key_checking）**不通过 env 配置**，请用 `ssh_connect` 工具参数或 `hosts.json`
+
+| 分类 | 变量 | 默认 | 说明 |
+|------|------|------|------|
+| **安全** | `SSH_SECURITY_LEVEL` | `balanced` | 安全级别：`strict` / `balanced` / `relaxed` |
+|  | `SSH_BASE_DIR` | `/home` | 路径校验基目录 |
+|  | `SSH_EXTRA_ALLOWED_COMMANDS` | (空) | 额外允许的命令（逗号分隔） |
+|  | `SSH_ALLOWED_COMMANDS_FILE` | (空) | 命令白名单 JSON 文件路径 |
+|  | `SSH_AUDIT_LOG_PATH` | (空) | 审计日志文件路径 |
+| **限流** | `SSH_RATE_LIMIT` | `true` | 限流总开关（bool） |
+|  | `SSH_RATE_LIMIT_MAX` | `30` | 限流次数上限 |
+|  | `SSH_RATE_LIMIT_WINDOW` | `60` | 限流窗口（秒） |
+| **硬拦截** | *(无 env)* | — | 灾难性命令硬拦截，零配置零绕过 |
+| **连接默认** | `SSH_HOST` / `SSH_PORT` / `SSH_USER` / `SSH_PASSWORD` | `127.0.0.1` / `22` / `root` / (空) | 单 host 模式默认连接参数 |
+|  | `SSH_TIMEOUT` | `60` | 连接超时（秒） |
+|  | `SSH_KEEPALIVE_INTERVAL` | `30` | keepalive 间隔（秒） |
+|  | `SSH_SESSION_TIMEOUT` | `7200` | 会话超时（秒） |
+|  | `SSH_CLIENT_TYPE` | `paramiko` | SSH 客户端实现：`paramiko` / `asyncssh` |
+|  | `SSH_FORCE_ENV_CONFIG` | `false` | 强制 env 配置覆盖 hosts.json |
+|  | `SSH_SUDO_PASSWORD` | (空) | sudo 密码，配合 `use_sudo=true` 走 `sudo -S` |
+
 ---
 
 ## ⚠️ 依赖版本兼容性

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssh-licco"
-version = "2.3.0"
+version = "2.4.0"
 description = "SSH Model Context Protocol Server - Enable SSH functionality for AI models"
 readme = "README.md"
 requires-python = ">=3.10"

{ssh_licco-2.3.0 → ssh_licco-2.4.0/ssh_licco.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 2.3.0
+Version: 2.4.0
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT
@@ -233,7 +233,6 @@ export SSH_EXTRA_ALLOWED_COMMANDS="git,pip,npm"
 
 - **[MCP_CONFIG_GUIDE.md](MCP_CONFIG_GUIDE.md)** - 完整配置指南，包含 5 种使用场景示例
 - **[SECURITY_CONFIG_GUIDE.md](SECURITY_CONFIG_GUIDE.md)** - 安全配置详解
-- **[docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)** - 生产加固四项方案（v2.1.0 新增）
 
 ### 🛡️ 硬拦截灾难性命令（v2.2.0 新增）
 
@@ -256,21 +255,6 @@ mv /path/to/junk /tmp/.trash_$(date +%s)/
 
 命中硬拦截时会输出 `WARNING` 审计日志（含 category 与命令），便于 SOC 监控。
 
-### 🏛️ 生产加固四项（v2.1.0 + v2.2.0 演进）
-
-SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
-
-| 加固点 | 开关 | 说明 |
-|--------|------|------|
-| 1. 运行账号最小权限 | `SSH_RUNTIME_GUARD=true` | 专用普通账号运行，拒绝 root/sudo 启动 |
-| 2. 密钥不落地磁盘 | `SSH_SECRET_PROVIDER_ENABLED=true` | 私钥从 KMS 临时拉取到内存，用完清零，不落盘 |
-| 3. 双层命令拦截 | `SSH_REMOTE_GUARD=true` + 远端 ForceCommand | 跳板机侧禁元字符 + 远端二次白名单校验 |
-| 4. 灾难性命令硬拦截（v2.2.0 新增） | 默认开启，不可关闭 | rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb、chmod -R 777/000 /、`> /dev/sd*` 等在 MCP 网关层被**无条件**拒绝；任何安全级别、`confirm_dangerous=true` 等均无法绕过 |
-
-> **关于 v2.1.0 引入的"高危操作审批"项**：v2.1.0 曾提供 `SSH_APPROVAL_GATE=true` + 3 个审批工具作为第 4 项加固。v2.2.0 起该项被**硬拦截取代**——审批流程依赖 AI 自报命令，存在闭环风险；硬拦截更直接，灾难性命令在 MCP 网关层就被拒绝，运维侧不需要再走"先申请再审批"流程。`SSH_APPROVAL_GATE` 环境变量与 `ssh_mcp/approval.py` / `ssh_mcp/handlers/approval.py` 代码已在 v2.2.0 删除。
-
-完整方案见 [docs/SECURITY_HARDENING.md](docs/SECURITY_HARDENING.md)。
-
 ---
 
 ## 🛠️ 可用工具（v2.2.0 维持 9 个；v2.1.0 曾增加的 3 个审批工具因流程闭环风险已下线）
@@ -278,7 +262,7 @@ SSH 跳板模式部署的生产必做加固，补齐跳板机单点风险：
 | 工具 | 描述 | 核心能力 |
 |------|------|---------|
 | `ssh_connect` | 连接管理 | 自动读取环境变量/配置，支持密码+密钥认证，可保存配置，登录后自动执行命令 |
-| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式；v2.1.0 新增 `remote_guard`（双层拦截）参数；v2.2.0 起对灾难性命令（rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb 等）做**无条件硬拦截** |
+| `ssh_execute` | 命令执行 | 自动连接、智能后台检测、长任务等待、超时控制，支持 nohup/screen/tmux 三种后台模式；v2.2.0 起对灾难性命令（rm -rf 绝对路径、mkfs、raw-disk dd、fork-bomb 等）做**无条件硬拦截** |
 | `ssh_disconnect` | 会话管理 | 断开指定会话 OR 列出所有活跃会话 |
 | `ssh_file_transfer` | 文件传输 | 上传/下载/列表/写入/追加/删除/创建目录/查看元信息（8 种操作）；v2.1.3+ delete 操作新增 Windows/Unix 敏感路径拦截与路径遍历防护 |
 | `ssh_host` | 主机管理 | `action=list/add/remove` 增删查主机配置 |
@@ -453,6 +437,31 @@ localhost:5432 - accepting connections
 
 - **[MCP_CONFIG_GUIDE.md](MCP_CONFIG_GUIDE.md)** - 包含所有配置选项的详细说明
 
+### 🌐 完整环境变量速查（v2.3.0）
+
+> 下表所有变量均被代码读取。**注意**：
+> - `SSH_RATE_LIMIT` 是 **bool** 总开关（true/false），`SSH_RATE_LIMIT_MAX` 才是次数上限，两者分开配置
+> - 主机密钥检查（strict_host_key_checking）**不通过 env 配置**，请用 `ssh_connect` 工具参数或 `hosts.json`
+
+| 分类 | 变量 | 默认 | 说明 |
+|------|------|------|------|
+| **安全** | `SSH_SECURITY_LEVEL` | `balanced` | 安全级别：`strict` / `balanced` / `relaxed` |
+|  | `SSH_BASE_DIR` | `/home` | 路径校验基目录 |
+|  | `SSH_EXTRA_ALLOWED_COMMANDS` | (空) | 额外允许的命令（逗号分隔） |
+|  | `SSH_ALLOWED_COMMANDS_FILE` | (空) | 命令白名单 JSON 文件路径 |
+|  | `SSH_AUDIT_LOG_PATH` | (空) | 审计日志文件路径 |
+| **限流** | `SSH_RATE_LIMIT` | `true` | 限流总开关（bool） |
+|  | `SSH_RATE_LIMIT_MAX` | `30` | 限流次数上限 |
+|  | `SSH_RATE_LIMIT_WINDOW` | `60` | 限流窗口（秒） |
+| **硬拦截** | *(无 env)* | — | 灾难性命令硬拦截，零配置零绕过 |
+| **连接默认** | `SSH_HOST` / `SSH_PORT` / `SSH_USER` / `SSH_PASSWORD` | `127.0.0.1` / `22` / `root` / (空) | 单 host 模式默认连接参数 |
+|  | `SSH_TIMEOUT` | `60` | 连接超时（秒） |
+|  | `SSH_KEEPALIVE_INTERVAL` | `30` | keepalive 间隔（秒） |
+|  | `SSH_SESSION_TIMEOUT` | `7200` | 会话超时（秒） |
+|  | `SSH_CLIENT_TYPE` | `paramiko` | SSH 客户端实现：`paramiko` / `asyncssh` |
+|  | `SSH_FORCE_ENV_CONFIG` | `false` | 强制 env 配置覆盖 hosts.json |
+|  | `SSH_SUDO_PASSWORD` | (空) | sudo 密码，配合 `use_sudo=true` 走 `sudo -S` |
+
 ---
 
 ## ⚠️ 依赖版本兼容性

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_licco.egg-info/SOURCES.txt

@@ -19,8 +19,6 @@ ssh_mcp/exceptions.py
 ssh_mcp/executor.py
 ssh_mcp/key_manager.py
 ssh_mcp/logging_config.py
-ssh_mcp/runtime_guard.py
-ssh_mcp/secret_provider.py
 ssh_mcp/security.py
 ssh_mcp/server.py
 ssh_mcp/service.py

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_mcp/__init__.py

@@ -1,8 +1,8 @@
 # SSH-LICCO 版本信息
 # 所有代码中的版本信息都从这里读取
-# 版本号：2.3.0
+# 版本号：2.4.0
 
-__version__ = "2.3.0"
+__version__ = "2.4.0"
 __author__ = "Li Qi"
 __email__ = "1985694657@qq.com"
 __license__ = "MIT"

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_mcp/connection_config.py

@@ -31,7 +31,7 @@ class ConnectionConfig(BaseModel):
     private_key_path: Path | None = Field(default=None, description="Path to private key file")
     private_key_material: str | None = Field(
         default=None,
-        description="内存中的私钥 PEM（密钥不落地模式：由 SecretProvider 临时拉取，不写入磁盘）",
+        description="In-memory private key PEM (used instead of private_key_path when key is provided as a string)",
     )
     passphrase: str | None = Field(default=None, description="Passphrase for private key")
     timeout: int = Field(default=30, description="Connection timeout in seconds")

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_mcp/handlers/connect.py

@@ -9,7 +9,6 @@ from mcp.types import TextContent
 
 from ..config_manager import SSHConfig, SSHHost
 from ..connection_config import ConnectionConfig
-from ..secret_provider import SecretManager, SecretProviderError
 from ..security import SecurityError, command_validator
 from .context import HandlerContext
 
@@ -94,35 +93,7 @@ async def handle_connect(ctx: HandlerContext, args: dict) -> list[TextContent]:
         or None
     )
 
-    # 加固点 2：密钥不落地磁盘
-    # 当 SecretManager 启用时，自动从 KMS 临时拉取私钥到内存，不读磁盘路径。
-    private_key_material: str | None = None
     private_key_path = Path(args["private_key_path"]) if args.get("private_key_path") else None
-    sm = SecretManager.instance()
-    secret_material = None
-    if sm.enabled and not private_key_path and not host_config.password:
-        # 仅在「无磁盘私钥 + 无密码」时尝试拉取（避免覆盖显式凭证）
-        secret_name = args.get("name") or getattr(host_config, "name", None) or host_config.host
-        try:
-            secret_material = sm.fetch(secret_name)
-            private_key_material = secret_material.as_str()
-            ctx.logger.info(
-                "[secret] 私钥从 KMS 临时拉取到内存"
-                f"（source={secret_material.source}, name={secret_name}），不落盘"
-            )
-        except SecretProviderError as e:
-            ctx.logger.error(f"[secret] 拉取私钥失败: {e}")
-            return [TextContent(type="text", text=f"密钥不落地模式：拉取私钥失败：{e}")]
-    elif sm.enabled and private_key_path:
-        return [
-            TextContent(
-                type="text",
-                text=(
-                    "密钥不落地模式已启用（SSH_SECRET_PROVIDER_ENABLED=true），"
-                    "禁止使用 private_key_path 指定磁盘私钥文件。请通过 SecretManager 配置凭证。"
-                ),
-            )
-        ]
 
     try:
         config = ConnectionConfig(
@@ -139,7 +110,7 @@ async def handle_connect(ctx: HandlerContext, args: dict) -> list[TextContent]:
             known_hosts_path=args.get("known_hosts_path"),
             accept_new_host_key=args.get("accept_new_host_key", True),
             private_key_path=private_key_path,
-            private_key_material=private_key_material,
+            private_key_material=None,
             passphrase=args.get("passphrase"),
             sudo_password=sudo_password,
         )
@@ -221,10 +192,7 @@ async def handle_connect(ctx: HandlerContext, args: dict) -> list[TextContent]:
             )
         ]
     finally:
-        # 加固点 2：连接建立/失败后立即清零内存中的私钥
-        # （paramiko 已在内部把私钥加载为 PKey 对象，原始 PEM 字符串不再需要）
-        if secret_material is not None:
-            sm.release(secret_material)
+        pass
 
 
 async def handle_disconnect(ctx: HandlerContext, args: dict) -> list[TextContent]:

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_mcp/handlers/execute.py

@@ -16,7 +16,6 @@ from .utils import (
     diagnose_exit_code,
     diagnose_startup_failure,
     ensure_session,
-    normalize_command_for_remote_guard,
     sanitize_remote_path,
     should_run_background,
 )
@@ -28,32 +27,6 @@ async def handle_execute(ctx: HandlerContext, args: dict) -> list[TextContent]:
     timeout = args.get("timeout", 120)  # 默认 120s，避免 docker pull/pg_basebackup 等长任务超时
     background = args.get("background", None)
 
-    # 加固点 3：双层命令拦截 — 第一层（跳板机侧）
-    # 当 remote_guard=True（或全局 SSH_REMOTE_GUARD=true）时，强制把命令规范为
-    # 单一 argv 形式，禁止 shell 元字符，防止远端 ForceCommand 的 bash -c 解析时
-    # 通过元字符注入绕过白名单。
-    remote_guard = (
-        args.get("remote_guard", False) or os.getenv("SSH_REMOTE_GUARD", "false").lower() == "true"
-    )
-    if remote_guard:
-        normalized, guard_err = normalize_command_for_remote_guard(command)
-        if guard_err:
-            ctx.logger.warning(f"Command blocked by remote_guard normalization: {command}")
-            return [
-                TextContent(
-                    type="text",
-                    text=(
-                        f"❌ 命令被远端 guard 模式拦截（第一层）\n\n"
-                        f"Command: {command}\n"
-                        f"Reason: {guard_err}\n\n"
-                        f"远端已启用 ForceCommand 二次校验，命令必须为单一 argv 形式，\n"
-                        f"禁止 shell 元字符（| ; & $() ` > < && ||）、子 shell、管道。\n"
-                        f"如需复杂命令，请在跳板机本地拆分为多条简单命令分别执行。"
-                    ),
-                )
-            ]
-        command = normalized
-
     # Resolve session via session_id / name / host / env fallback
     session_id = await ensure_session(ctx, args, handle_connect)
     if not session_id:

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_mcp/handlers/schemas.py

@@ -137,11 +137,6 @@ TOOLS: dict[str, Tool] = {
                     "default": False,
                     "description": "Bypass security validation for known-dangerous commands (e.g. rm -rf /path). Use with caution — only for operations you explicitly intend to perform.",
                 },
-                "remote_guard": {
-                    "type": "boolean",
-                    "default": False,
-                    "description": "加固点 3：标记远端已启用 ForceCommand 二次校验。启用后 ssh-licco 侧会强制把命令规范为单一 argv 形式下发，禁止 shell 元字符，确保远端 bash -c 解析时无法绕过白名单。",
-                },
             },
             "required": ["command"],
         },

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_mcp/handlers/utils.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import re
-import shlex
 from collections.abc import Awaitable, Callable
 
 from mcp.types import TextContent
@@ -69,52 +68,6 @@ async def ensure_session(
     return None
 
 
-def normalize_command_for_remote_guard(command: str) -> tuple[str, str | None]:
-    """加固点 3：把命令规范为远端 ForceCommand 可安全解析的形式。
-
-    remote_guard 模式下，远端 sshd 的 ForceCommand 脚本会用 `bash -c "$SSH_ORIGINAL_COMMAND"`
-    执行。如果原始命令包含 shell 元字符（| ; & $() ` 等），bash -c 解析时会拆分出
-    多条命令或子 shell，绕过 ForceCommand 脚本的白名单校验（白名单只看第一个 token）。
-
-    因此本方法在跳板机侧（第一层）就把命令强制规范为「单一命令 + 参数」形式：
-      - 禁止管道 |、命令分隔 ;、后台 &、逻辑 && ||、命令替换 $() ``、重定向 > <、子 shell ()
-      - 允许普通参数（含路径、引号包裹的字符串参数）
-      - 返回 (规范化后的命令, 错误信息)；错误信息非 None 表示被拦截
-
-    这样远端 ForceCommand 解析出的「基础命令」就是真实要执行的那个，无法通过元字符
-    注入隐藏的第二条命令。
-    """
-    if not command or not command.strip():
-        return command, "命令为空"
-
-    # 远端 guard 模式下禁止的元字符/构造
-    forbidden = ["|", ";", "&", "&&", "||", "$(", ")", "`", ">", "<", "\n", "\r"]
-    for token in forbidden:
-        if token in command:
-            return command, (
-                f"命令包含禁止的 shell 元字符 '{token}'。"
-                f"远端 guard 模式要求单一 argv，禁止管道/重定向/命令替换/子 shell。"
-            )
-
-    # 子 shell 圆括号（前面已拦 ')'，这里再拦开括号 '(' 作为保险）
-    if "(" in command:
-        return command, "命令包含禁止的子 shell 构造 '('"
-    # 命令长度校验
-    if len(command) > 4096:
-        return command, "命令过长（最大 4096 字符）"
-
-    # 通过 shlex 解析验证命令格式合法（不实际执行）
-    try:
-        parts = shlex.split(command)
-    except ValueError as e:
-        return command, f"命令格式无法解析：{e}"
-    if not parts:
-        return command, "命令解析后为空"
-
-    # 返回原命令（已通过元字符检查），远端 bash -c 会安全解析
-    return command, None
-
-
 def diagnose_exit_code(exit_code: int, log_tail: str, stderr: str) -> str:
     """根据退出码和日志输出诊断命令失败原因"""
     combined = (log_tail + " " + stderr).lower()

{ssh_licco-2.3.0 → ssh_licco-2.4.0}/ssh_mcp/key_manager.py

@@ -116,9 +116,6 @@ class KeyManager:
     def load_key_from_str(self, private_key_pem: str, passphrase: str | None = None) -> SSHKeyPair:
         """从内存字符串加载私钥，不接触磁盘。
 
-        用于「密钥不落地」加固场景：私钥由 SecretProvider 从 KMS 临时拉取到内存，
-        通过本方法解析为 SSHKeyPair，用完即由调用方清零。
-
         Args:
             private_key_pem: PEM 格式私钥字符串
             passphrase: 私钥口令（可选）
@@ -161,15 +158,6 @@ class KeyManager:
         )
 
     def save_key(self, key_pair: SSHKeyPair, private_key_path: Path) -> None:
-        # 加固点 2：密钥不落地磁盘
-        # 当 SSH_SECRET_PROVIDER_ENABLED=true 时，禁止把私钥写入磁盘。
-        from .secret_provider import is_secret_provider_enabled
-
-        if is_secret_provider_enabled():
-            raise PermissionError(
-                "密钥不落地模式已启用（SSH_SECRET_PROVIDER_ENABLED=true），"
-                "禁止将私钥写入磁盘。私钥应通过 SecretProvider 临时拉取到内存使用。"
-            )
         private_key_path.parent.mkdir(parents=True, exist_ok=True)
         with open(private_key_path, "w") as f:
             f.write(key_pair.private_key)

ssh_licco-2.3.0/ssh_mcp/runtime_guard.py

@@ -1,178 +0,0 @@
-"""SSH-LICCO 运行时守护 — 加固点 1：运行账号最小权限
-
-生产跳板机部署 ssh-licco 时，必须以专用普通运维账号启动，禁止 root / 禁止 sudo。
-本模块在进程入口（run_server）处强制校验运行身份，发现违规立即拒绝启动。
-
-启用方式（环境变量）：
-    SSH_RUNTIME_GUARD=true            # 总开关，默认 false（开发/测试不强制）
-    SSH_RUNTIME_ALLOW_ROOT=false      # 是否允许 root 启动，默认 false
-    SSH_RUNTIME_ALLOWED_USERS=        # 逗号分隔的允许账号白名单，留空表示不限制具体用户名
-                                       例如：sshlicco,ops
-    SSH_RUNTIME_BLOCK_SUDO=true       # 检测 SUDO_* / PKEXEC_* 等提权环境变量，默认 true
-
-为什么这样设计：
-    - 跳板机是 SSH 代理的唯一执行点，进程权限 = 可下发的最大远端命令权限上限。
-    - root / sudo 启动会让命令白名单形同虚设：任何白名单内的命令都能以 root 身份
-      在跳板机本地造成破坏（例如读取本地私钥、改 hosts.json、注入 sudo_password）。
-    - 因此"运行账号最小权限"是其它三项加固（密钥不落地、双层拦截、审批）的前置条件。
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-from dataclasses import dataclass
-
-
-class RuntimeGuardError(RuntimeError):
-    """运行身份校验失败"""
-
-
-@dataclass
-class RuntimeCheckResult:
-    ok: bool
-    reason: str
-    current_user: str
-    is_root: bool
-    is_sudo_context: bool
-
-
-def _posix_user_name(uid: int) -> str:
-    try:
-        import pwd  # 仅 POSIX 可用
-
-        return pwd.getpwuid(uid).pw_name
-    except Exception:
-        return str(uid)
-
-
-def _current_user_name() -> str:
-    """获取当前运行账号名。Windows 下返回 USERNAME 环境变量（仅用于提示，不强制）。"""
-    if os.name == "posix":
-        try:
-            return _posix_user_name(os.getuid())
-        except Exception:
-            return os.getenv("USER", "unknown")
-    # Windows 不强制（生产跳板机本身是 Linux），仅用于日志提示
-    return os.getenv("USERNAME") or os.getenv("USER") or "unknown-windows-user"
-
-
-def _is_root() -> bool:
-    if os.name != "posix":
-        return False
-    return os.geteuid() == 0
-
-
-def _is_sudo_context() -> bool:
-    """检测 sudo / doas / pkexec 提权环境。"""
-    sudo_markers = (
-        "SUDO_USER",
-        "SUDO_UID",
-        "SUDO_GID",
-        "SUDO_COMMAND",
-        "PKEXEC_UID",
-        "DOAS_USER",
-    )
-    return any(os.getenv(m) for m in sudo_markers)
-
-
-def check_runtime_identity() -> RuntimeCheckResult:
-    """执行运行账号最小权限校验。返回检查结果，不抛异常。"""
-    current_user = _current_user_name()
-    is_root = _is_root()
-    is_sudo = _is_sudo_context()
-
-    # POSIX 之外（Windows 开发环境）直接放行，生产跳板机本身是 Linux
-    if os.name != "posix":
-        return RuntimeCheckResult(
-            ok=True,
-            reason=f"non-POSIX platform ({os.name}), runtime guard skipped (dev only)",
-            current_user=current_user,
-            is_root=is_root,
-            is_sudo_context=is_sudo,
-        )
-
-    allow_root = os.getenv("SSH_RUNTIME_ALLOW_ROOT", "false").lower() == "true"
-    block_sudo = os.getenv("SSH_RUNTIME_BLOCK_SUDO", "true").lower() == "true"
-    allowed_users_raw = os.getenv("SSH_RUNTIME_ALLOWED_USERS", "").strip()
-    allowed_users = {u.strip() for u in allowed_users_raw.split(",") if u.strip()}
-
-    # 1. root 拦截
-    if is_root and not allow_root:
-        return RuntimeCheckResult(
-            ok=False,
-            reason=(
-                "ssh-licco 进程以 root 身份启动被拒绝。\n"
-                "  生产跳板机必须使用专用普通运维账号运行，禁止 root 启动。\n"
-                "  排查：检查 systemd unit 的 User= / 启动脚本的 su/sudo。\n"
-                "  如确实需要在 root 下临时调试，设置 SSH_RUNTIME_ALLOW_ROOT=true（不推荐）。"
-            ),
-            current_user=current_user,
-            is_root=is_root,
-            is_sudo_context=is_sudo,
-        )
-
-    # 2. sudo 上下文拦截
-    if is_sudo and block_sudo:
-        return RuntimeCheckResult(
-            ok=False,
-            reason=(
-                "ssh-licco 进程在 sudo/doas/pkexec 提权上下文中启动被拒绝。\n"
-                "  生产跳板机禁止通过 sudo 启动 ssh-licco，请直接以专用账号登录后启动。\n"
-                "  如需临时调试，设置 SSH_RUNTIME_BLOCK_SUDO=false（不推荐）。"
-            ),
-            current_user=current_user,
-            is_root=is_root,
-            is_sudo_context=is_sudo,
-        )
-
-    # 3. 用户白名单
-    if allowed_users and current_user not in allowed_users:
-        return RuntimeCheckResult(
-            ok=False,
-            reason=(
-                f"ssh-licco 进程以账号 '{current_user}' 启动，不在白名单 {sorted(allowed_users)} 中。\n"
-                "  请使用 SSH_RUNTIME_ALLOWED_USERS 中声明的专用运维账号启动。"
-            ),
-            current_user=current_user,
-            is_root=is_root,
-            is_sudo_context=is_sudo,
-        )
-
-    return RuntimeCheckResult(
-        ok=True,
-        reason="runtime identity OK",
-        current_user=current_user,
-        is_root=is_root,
-        is_sudo_context=is_sudo,
-    )
-
-
-def enforce_runtime_guard() -> None:
-    """入口处调用：开启守护时若校验失败，打印原因并 sys.exit(2)。
-
-    未开启守护（SSH_RUNTIME_GUARD 未设为 true）时仅打印提示，不强制。
-    """
-    enabled = os.getenv("SSH_RUNTIME_GUARD", "false").lower() == "true"
-    result = check_runtime_identity()
-
-    if result.ok:
-        # 即使通过，也把运行账号落到日志，便于审计
-        print(
-            f"[runtime_guard] identity check passed: user={result.current_user} "
-            f"root={result.is_root} sudo_ctx={result.is_sudo_context}",
-            file=sys.stderr,
-        )
-        return
-
-    # 校验失败
-    if enabled:
-        print(f"[runtime_guard] FATAL: {result.reason}", file=sys.stderr)
-        sys.exit(2)
-    else:
-        # 未开启守护，仅警告（开发/测试环境）
-        print(
-            f"[runtime_guard] WARNING (not enforced, set SSH_RUNTIME_GUARD=true to enforce): "
-            f"{result.reason}",
-            file=sys.stderr,
-        )

ssh_licco-2.3.0/ssh_mcp/secret_provider.py

@@ -1,226 +0,0 @@
-"""SSH-LICCO 凭证管理 — 加固点 2：密钥不落地磁盘
-
-生产跳板机托管的服务器私钥，不能以明文文件形式持久保存在跳板机磁盘上。
-本模块提供 SecretProvider 抽象 + 多种后端实现，从外部密钥管理服务（KMS）临时
-拉取私钥到内存中使用，进程退出（或连接关闭）时立即清理：
-
-  ┌──────────────┐     fetch-on-demand      ┌────────────────┐
-  │  ssh-licco   │ ───────────────────────▶ │ KMS / Vault /  │
-  │  (in memory) │ ◀─────────────────────── │  env-injected  │
-  └──────────────┘   私钥仅存于进程内存      └────────────────┘
-        │
-        │  atexit / session close
-        ▼
-    立即清零内存中的私钥字节
-
-支持的后端（通过环境变量 SSH_SECRET_PROVIDER 选择）：
-
-  - env     : 私钥直接从环境变量读取（开发/CI 用，仍不落盘）
-              SSH_SECRET_ENV_KEY_<NAME> 指定每个连接的私钥环境变量名
-  - command : 执行外部命令（如 vault kv get / aws secretsmanager get）拉取私钥
-              SSH_SECRET_COMMAND_<NAME> 指定命令，stdout 即私钥内容
-  - http    : 从 HTTP(S) 接口拉取，请求头携带 SSH_SECRET_HTTP_TOKEN
-              SSH_SECRET_HTTP_URL_<NAME> / SSH_SECRET_HTTP_TOKEN 配置
-
-设计原则：
-  - 私钥内容绝不写入磁盘文件；KeyManager.save_key 在「密钥不落地」模式启用时
-    会抛错，强制走内存路径。
-  - 私钥字节在不再使用时显式清零（best-effort，Python 字符串不可变，但 bytes
-    可通过 ctypes.memset 清零；这里用 bytearray + del 最大化清理效果）。
-  - 临时凭证缓存仅存活于进程生命周期，atexit 钩子统一清理。
-"""
-
-from __future__ import annotations
-
-import atexit
-import os
-import subprocess
-import threading
-import urllib.request
-from dataclasses import dataclass
-
-
-class SecretProviderError(RuntimeError):
-    """凭证拉取失败"""
-
-
-@dataclass
-class SecretMaterial:
-    """拉取到的凭证材料。使用完应调用 wipe() 清零。"""
-
-    name: str  # 连接名 / 凭证标识
-    data: bytearray  # 私钥内容（bytearray 便于清零）
-    source: str  # 来源描述（env/command/http），便于审计
-
-    def as_str(self) -> str:
-        return self.data.decode("utf-8", errors="strict")
-
-    def wipe(self) -> None:
-        """清零内存中的私钥字节（best-effort）。"""
-        for i in range(len(self.data)):
-            self.data[i] = 0
-        self.data.clear()
-
-
-class SecretProvider:
-    """凭证提供者抽象基类。子类实现 fetch()。"""
-
-    def fetch(self, name: str) -> SecretMaterial:  # pragma: no cover - abstract
-        raise NotImplementedError
-
-    def close(self) -> None:
-        """清理资源（如 HTTP keep-alive 连接）。默认无操作。"""
-
-
-class EnvSecretProvider(SecretProvider):
-    """从环境变量读取私钥。"""
-
-    def fetch(self, name: str) -> SecretMaterial:
-        var = os.getenv(f"SSH_SECRET_ENV_KEY_{name.upper()}") or os.getenv(
-            f"SSH_SECRET_ENV_KEY_{name}"
-        )
-        if not var:
-            # 兼容：直接以 name 作为变量名
-            var = os.getenv(name)
-        if not var:
-            raise SecretProviderError(
-                f"env provider: 私钥环境变量未配置（尝试过 SSH_SECRET_ENV_KEY_{name.upper()} / {name}）"
-            )
-        return SecretMaterial(name=name, data=bytearray(var.encode("utf-8")), source="env")
-
-
-class CommandSecretProvider(SecretProvider):
-    """执行外部命令拉取私钥。stdout 即私钥 PEM 内容。"""
-
-    def fetch(self, name: str) -> SecretMaterial:
-        cmd = os.getenv(f"SSH_SECRET_COMMAND_{name.upper()}") or os.getenv(
-            f"SSH_SECRET_COMMAND_{name}"
-        )
-        if not cmd:
-            raise SecretProviderError(f"command provider: 未配置 SSH_SECRET_COMMAND_{name.upper()}")
-        try:
-            proc = subprocess.run(
-                cmd,
-                shell=True,
-                capture_output=True,
-                timeout=30,
-                check=True,
-                text=False,  # 拿 bytes 自行管理清零
-            )
-        except subprocess.CalledProcessError as e:
-            raise SecretProviderError(
-                f"command provider: 命令退出码 {e.returncode}: {e.stderr.decode('utf-8', 'replace')}"
-            )
-        except subprocess.TimeoutExpired:
-            raise SecretProviderError("command provider: 拉取私钥命令超时（>30s）")
-        return SecretMaterial(name=name, data=bytearray(proc.stdout), source="command")
-
-
-class HttpSecretProvider(SecretProvider):
-    """从 HTTP(S) 接口拉取私钥。"""
-
-    def __init__(self):
-        self._token = os.getenv("SSH_SECRET_HTTP_TOKEN", "")
-        self._timeout = float(os.getenv("SSH_SECRET_HTTP_TIMEOUT", "15"))
-
-    def fetch(self, name: str) -> SecretMaterial:
-        url = os.getenv(f"SSH_SECRET_HTTP_URL_{name.upper()}") or os.getenv(
-            f"SSH_SECRET_HTTP_URL_{name}"
-        )
-        if not url:
-            raise SecretProviderError(f"http provider: 未配置 SSH_SECRET_HTTP_URL_{name.upper()}")
-        req = urllib.request.Request(url)
-        if self._token:
-            req.add_header("Authorization", f"Bearer {self._token}")
-        try:
-            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
-                body = resp.read()
-        except Exception as e:
-            raise SecretProviderError(f"http provider: 拉取 {name} 失败: {e}")
-        return SecretMaterial(name=name, data=bytearray(body), source="http")
-
-
-_PROVIDERS: dict[str, type[SecretProvider]] = {
-    "env": EnvSecretProvider,
-    "command": CommandSecretProvider,
-    "http": HttpSecretProvider,
-}
-
-
-class SecretManager:
-    """凭证管理器：单例，负责 provider 选择、内存缓存、atexit 清理。
-
-    使用方式（在 ssh_connect 处理器中）：
-        sm = SecretManager.instance()
-        if sm.enabled:
-            material = sm.fetch(host_name)        # 拉到内存
-            try:
-                pair = KeyManager().load_key_from_str(material.as_str())
-                ...用 pair 建立 SSH 连接...
-            finally:
-                sm.release(material)              # 用完立即清零
-    """
-
-    _instance: SecretManager | None = None
-    _lock = threading.Lock()
-
-    def __init__(self):
-        self.enabled = os.getenv("SSH_SECRET_PROVIDER_ENABLED", "false").lower() == "true"
-        provider_kind = os.getenv("SSH_SECRET_PROVIDER", "env").lower()
-        self._provider: SecretProvider | None = None
-        if self.enabled:
-            cls = _PROVIDERS.get(provider_kind)
-            if cls is None:
-                raise SecretProviderError(
-                    f"未知的 SSH_SECRET_PROVIDER={provider_kind!r}，可选: {list(_PROVIDERS)}"
-                )
-            self._provider = cls()
-            # 注册进程退出清理
-            atexit.register(self.shutdown)
-        # 当前进程持有的所有凭证材料（用于退出时统一清零）
-        self._live: list[SecretMaterial] = []
-        self._live_lock = threading.Lock()
-
-    @classmethod
-    def instance(cls) -> SecretManager:
-        with cls._lock:
-            if cls._instance is None:
-                cls._instance = cls()
-            return cls._instance
-
-    def fetch(self, name: str) -> SecretMaterial:
-        if not self.enabled or self._provider is None:
-            raise SecretProviderError("secret manager 未启用（SSH_SECRET_PROVIDER_ENABLED=true）")
-        material = self._provider.fetch(name)
-        with self._live_lock:
-            self._live.append(material)
-        return material
-
-    def release(self, material: SecretMaterial) -> None:
-        """归还凭证：从 live 列表移除并清零。"""
-        with self._live_lock:
-            try:
-                self._live.remove(material)
-            except ValueError:
-                pass
-        material.wipe()
-
-    def shutdown(self) -> None:
-        """进程退出时统一清零所有未释放的凭证。"""
-        with self._live_lock:
-            for m in self._live:
-                try:
-                    m.wipe()
-                except Exception:
-                    pass
-            self._live.clear()
-        if self._provider is not None:
-            try:
-                self._provider.close()
-            except Exception:
-                pass
-
-
-def is_secret_provider_enabled() -> bool:
-    """便捷查询：是否启用了密钥不落地模式。"""
-    return SecretManager.instance().enabled