凭证管理器

状态：强制性安全基础

将分散的 API 密钥和凭证集中到一个安全的 .env 文件中。

⚠️ 此操作不可忽略

集中式 .env 凭证管理是 OpenClaw 安全的核心要求。如果您的凭证分散在多个文件中，请立即停止并进行整合。

规则： 所有凭证必须仅存在于 ~/.openclaw/.env 中。不允许在工作区、技能目录或脚本目录中存在。

参考：

• [CORE-PRINCIPLE.md](CORE-PRINCIPLE.md) - 为何此规则不可妥协
• [CONSOLIDATION-RULE.md](CONSOLIDATION-RULE.md) - 单一来源原则

基础要求

每个 OpenClaw 部署都必须包含：

~/.openclaw/.env (权限模式 600)

这是所有凭证的唯一可信来源。无一例外。

原因：

• 单一位置 = 更易防护
• 权限模式 600 = 仅用户可读
• Git 忽略 = 不会意外提交
• 格式验证 = 可发现错误
• 审计追踪 = 知晓变更内容

分散的凭证 = 分散的攻击面。此技能正是为解决这一问题而设计。

本技能功能

1. 扫描常见位置中的凭证（包括对硬编码密钥的深度扫描）
2. 备份现有凭证文件（带时间戳，权限模式 600）
3. 整合至 ~/.openclaw/.env
4. 加固权限（文件设为 600，目录设为 700）
5. 验证安全性、格式与熵值
6. 加密高价值秘密（使用 GPG，如钱包私钥、私钥、助记词）
7. 追踪凭证轮换计划
8. 通过快速失败检查强制执行最佳实践
9. 清理迁移后旧文件

检测参数

该技能自动通过扫描检测凭证：

文件模式匹配：

• ~/.config/*/credentials.json — 服务配置目录
• ~/.config/*/*.credentials.json — 嵌套凭证文件
• ~/.openclaw/*.json — OpenClaw 根目录下的凭证文件
• ~/.openclaw/*-credentials* — 命名凭证文件（如 farcaster-credentials.json）
• ~/.openclaw/workspace/memory/*-creds.json — 内存凭证文件
• ~/.openclaw/workspace/memory/*credentials*.json — 内存凭证文件
• ~/.openclaw/workspace/.env — 工作区环境文件
• ~/.openclaw/workspace/*/.env — 子目录环境文件
• ~/.openclaw/workspace/skills/*/.env — 技能环境文件
• ~/.local/share/*/credentials.json — 本地共享目录

敏感键值模式：

• API 密钥、访问令牌、承载令牌
• 秘密、密码、口令
• OAuth 消费者密钥
• 私钥、签名密钥、钱包密钥
• 助记词和种子短语

深度扫描（--deep 标志）：

• 在 .sh、.js、.py、.mjs、.ts 文件中搜索硬编码密钥
• 检测符合常见前缀（sk_、pk_、Bearer、0x + 64 位十六进制）的高熵字符串
• 排除 node_modules/、.git/
• 报告文件名、行号及匹配的密钥模式

安全检查：

• 文件权限（文件必须为 600，目录必须为 700）
• 备份权限（备份文件必须为 600，备份目录必须为 700）
• Git 忽略保护
• 格式验证（支持带空格的引号值）
• 熵值分析（标记熵值过低的可疑密钥）
• 私钥检测（标记 0x + 64 位十六进制字符值）
• 助记词检测（标记 12 或 24 个单词的值）
• 符号链接检测（验证符号链接指向的 .env 目标）

快速开始

完整迁移（推荐）

# 扫描凭证
./scripts/scan.py

# 深度扫描（包含脚本中的硬编码密钥）
./scripts/scan.py --deep

# 审查并整合
./scripts/consolidate.py

# 验证安全性
./scripts/validate.py

# 加密高价值密钥
./scripts/encrypt.py --keys MAIN_WALLET_PRIVATE_KEY,CUSTODY_PRIVATE_KEY

# 检查轮换状态
./scripts/rotation-check.py

单独操作

# 仅扫描
./scripts/scan.py

# 整合特定服务
./scripts/consolidate.py --service x

# 仅备份不删除
./scripts/consolidate.py --backup-only

# 清理旧文件
./scripts/cleanup.py --confirm

常见凭证位置

该技能会扫描以下位置：

~/.config/*/credentials.json
~/.openclaw/*.json
~/.openclaw/*-credentials*
~/.openclaw/workspace/memory/*-creds.json
~/.openclaw/workspace/memory/*credentials*.json
~/.openclaw/workspace/*/.env
~/.openclaw/workspace/skills/*/.env
~/.env (若存在，则合并)

安全特性

✅ 文件权限： 将 .env 设置为 600 模式（仅所有者可读）

✅ 目录权限： 将备份目录设置为 700 模式（仅所有者可访问）

✅ 备份权限： 将备份文件设置为 600 模式（仅所有者可读）

✅ Git 保护： 创建/更新 .gitignore 文件

✅ 备份机制： 迁移前生成带时间戳的备份（已加密保护）

✅ 验证功能： 检查格式、权限、熵值与重复项

✅ 模板生成： 创建 .env.example（可安全分享）

✅ GPG 加密： 对高价值密钥进行静态加密

✅ 轮换追踪： 当凭证需轮换时发出警告

✅ 深度扫描： 检测源代码中的硬编码密钥

✅ 符号链接感知： 验证符号链接指向的 .env 目标

输出结构

迁移完成后：

~/.openclaw/
├── .env                     # 所有凭证（安全，权限 600）
├── .env.secrets.gpg         # GPG 加密的高价值密钥（权限 600）
├── .env.meta                # 轮换元数据（权限 600）
├── .env.example             # 模板文件（可安全分享）
├── .gitignore               # 保护 .env 和 .env.secrets.gpg
└── backups/                 # （权限 700）
    └── credentials-old-YYYYMMDD/  # （权限 700）
        └── *.bak            # 备份文件（权限 600）

GPG 加密高价值密钥

私钥、钱包密钥和助记词应永远不要以明文形式存储于磁盘。请使用 GPG 加密这些高价值信息。

设置 GPG

# 首次设置（生成 OpenClaw GPG 密钥，并配置代理缓存）
./scripts/setup-gpg.sh

加密高价值密钥

OpenClaw 凭据管理器

加密特定密钥（将它们从 .env 移动到 .env.secrets.gpg）

./scripts/encrypt.py --keys MAIN_WALLET_PRIVATE_KEY,CUSTODY_PRIVATE_KEY,SIGNER_PRIVATE_KEY

加密后，.env 文件将包含占位符：

MAIN_WALLET_PRIVATE_KEY=GPG:MAIN_WALLET_PRIVATE_KEY

脚本如何访问加密密钥

enforce.py 模块会透明地处理此过程：

from enforce import get_credential

# 适用于明文和 GPG 加密的密钥
key = get_credential('MAIN_WALLET_PRIVATE_KEY')
# 如果值以 "GPG:" 开头，则自动从 .env.secrets.gpg 解密

GPG 代理缓存

在无头服务器（VPS）上，GPG 代理会缓存密码短语：

• 默认缓存有效期：8 小时
• 可通过 setup-gpg.sh 配置
• 重启后只需输入一次密码，之后将被缓存

哪些密钥需要加密

凭据轮换跟踪

设置轮换元数据

# 为所有密钥初始化轮换跟踪
./scripts/rotation-check.py --init

创建 ~/.openclaw/.env.meta：

{
  "MAIN_WALLET_PRIVATE_KEY": {
    "created": "2026-01-15",
    "lastRotated": null,
    "rotationDays": 90,
    "risk": "critical"
  },
  "MOLTBOOK_API_KEY": {
    "created": "2026-02-04",
    "lastRotated": null,
    "rotationDays": 180,
    "risk": "low"
  }
}

检查轮换状态

# 检查哪些密钥需要轮换
./scripts/rotation-check.py

# 输出示例：
# 🔴 MAIN_WALLET_PRIVATE_KEY: 已使用 26 天（高危，每 90 天轮换一次）
# ✅ MOLTBOOK_API_KEY: 已使用 7 天（低风险，每 180 天轮换一次）

轮换周期

添加到心跳检查（可选）

将轮换检查加入 HEARTBEAT.md 实现定期监控：

## 凭据轮换（每周）
若距离上次轮换检查已超过 7 天：
1. 运行：./scripts/rotation-check.py
2. 若存在过期密钥：通知人工
3. 更新 lastRotationCheck 时间戳

支持的服务

常见服务可自动识别：

• X（Twitter）： OAuth 1.0a 凭据
• Farcaster： 托管密钥、签名密钥、FID 凭据
• Molten： 代理意图匹配
• Moltbook： 代理社交网络
• Botchan/4claw： Net 协议
• OpenAI、Anthropic、Google： AI 服务商
• GitHub、GitLab： 代码托管
• Coinbase/CDP： 加密钱包凭据
• 通用： API_KEY、*_TOKEN、*_SECRET 等模式

完整列表请参见 [references/supported-services.md](references/supported-services.md)。

脚本说明

所有脚本均支持 --help 查看详细用法。

scan.py

# 扫描并报告
./scripts/scan.py

# 深度扫描（包括脚本中硬编码的密钥）
./scripts/scan.py --deep

# 包含自定义路径
./scripts/scan.py --paths ~/.myapp/config ~/.local/share/creds

# JSON 格式输出
./scripts/scan.py --format json

consolidate.py

# 交互模式（更改前提示确认）
./scripts/consolidate.py

# 自动确认（不提示）
./scripts/consolidate.py --yes

# 仅备份
./scripts/consolidate.py --backup-only

# 指定服务
./scripts/consolidate.py --service molten

validate.py

# 完整验证（权限、格式、熵值、安全性）
./scripts/validate.py

# 仅检查权限
./scripts/validate.py --check permissions

# 自动修复问题
./scripts/validate.py --fix

encrypt.py

# 加密特定高价值密钥
./scripts/encrypt.py --keys MAIN_WALLET_PRIVATE_KEY,CUSTODY_PRIVATE_KEY

# 列出当前已加密的密钥
./scripts/encrypt.py --list

# 解密（移回明文 .env）
./scripts/encrypt.py --decrypt --keys MAIN_WALLET_PRIVATE_KEY

rotation-check.py

# 检查轮换状态
./scripts/rotation-check.py

# 初始化所有密钥的轮换跟踪
./scripts/rotation-check.py --init

# 记录一次轮换
./scripts/rotation-check.py --rotated MOLTBOOK_API_KEY

setup-gpg.sh

# OpenClaw 的首次 GPG 设置
./scripts/setup-gpg.sh

# 配置缓存超时（小时）
./scripts/setup-gpg.sh --cache-hours 12

cleanup.py

# 干运行（显示将删除的内容）
./scripts/cleanup.py

# 实际删除旧文件
./scripts/cleanup.py --confirm

# 保留备份
./scripts/cleanup.py --confirm --keep-backups

迁移工作流

以下是经过实际部署验证的完整步骤流程。

步骤 1：扫描分散的凭据

cd /path/to/openclaw/skills/credential-manager

# 基础扫描 —— 通过路径模式查找凭据文件
./scripts/scan.py

# 深度扫描 —— 也搜索源码文件中的硬编码密钥
./scripts/scan.py --deep

需关注的输出内容：

• ⚠️ 文件权限不是 600（安全风险）
• 符号链接的 .env 文件（应指向主 ~/.openclaw/.env）
• 位于 ~/.openclaw/.env 外部的 JSON 凭据文件
• 深度扫描发现脚本中硬编码的密钥

示例输出：

⚠️ /home/user/.openclaw/farcaster-credentials.json
   类型: json
   密钥: custodyPrivateKey, signerPrivateKey, ...
   权限: 644
   ⚠️ 应设置为 600 以保证安全

✅ /home/user/.openclaw/.env
   类型: env
   密钥: API_KEY, X_CONSUMER_KEY, ...
   权限: 600

步骤 2：合并至 .env

./scripts/consolidate.py

交互流程：

1. 脚本扫描并列出所有找到的凭据文件
2. 将现有 .env 备份至 ~/.openclaw/backups/credentials-old-YYYYMMDD/
3. 加载原有 .env 中的密钥
4. 处理每个凭据文件：

- 自动识别服务（x、farcaster、moltbook、molten 等）

- 统一密钥命名（如 custodyPrivateKey → FARCASTER_CUSTODY_PRIVATE_KEY）

- 显示映射关系：原始键 → ENV_KEY

1. 提示确认：是否继续？[y/N]
2. 写入合并后的 .env（权限设为 600）
3. 创建 .env.example 模板（可安全分享）
4. 更新 .gitignore

对于未被自动检测到的凭据（例如嵌套 JSON 格式文件，如 farcaster-credentials.json 中包含多个账户），请手动添加至 .env 文件：

cat >> ~/.openclaw/.env << 'EOF'

# FARCASTER（当前活跃：mr-teeclaw，FID 2700953）
FARCASTER_FID=2700953
FARCASTER_FNAME=mr-teeclaw
FARCASTER_CUSTODY_ADDRESS=0x...
FARCASTER_CUSTODY_PRIVATE_KEY=0x...
FARCASTER_SIGNER_PUBLIC_KEY=...
FARCASTER_SIGNER_PRIVATE_KEY=...

# FARCASTER 旧版账户（teeclaw，FID 2684290）
FARCASTER_LEGACY_FID=2684290
FARCASTER_LEGACY_CUSTODY_ADDRESS=0x...
FARCASTER_LEGACY_CUSTODY_PRIVATE_KEY=0x...
FARCASTER_LEGACY_SIGNER_PUBLIC_KEY=...
FARCASTER_LEGACY_SIGNER_PRIVATE_KEY=...
EOF

chmod 600 ~/.openclaw/.env

步骤 3：验证配置

./scripts/validate.py

执行的检查项：

• ✅ .env 文件权限（必须为 600）
• ✅ .gitignore 覆盖情况
• ✅ 格式校验（键名格式、引号使用、重复项）
• ✅ 安全性分析：

- 检测明文私钥（以 0x 开头且长度为 64 位十六进制字符）→ 建议使用 GPG 加密

- 检测助记词/种子短语（12 或 24 个单词）→ 建议使用 GPG 加密

- 对 SECRET / PRIVATE_KEY / PASSWORD 等字段进行熵值分析

- 标记弱密码或占位符值

• ✅ 备份文件权限（文件必须为 600，目录必须为 700）

自动修复问题：

./scripts/validate.py --fix

此命令可自动修复：文件权限、目录权限、备份权限、.gitignore 配置。

但不会自动修复格式错误或加密私钥 —— 这些需手动处理。

步骤 4：设置 GPG 并加密私钥

# 首次使用 GPG 设置（配置代理缓存，测试加解密功能）
./scripts/setup-gpg.sh
# 可选参数：--cache-hours 12（默认为 8 小时）

加密高价值密钥：

# 加密钱包及 Farcaster 私钥
./scripts/encrypt.py --keys MAIN_WALLET_PRIVATE_KEY,FARCASTER_CUSTODY_PRIVATE_KEY,FARCASTER_SIGNER_PRIVATE_KEY,FARCASTER_LEGACY_CUSTODY_PRIVATE_KEY,FARCASTER_LEGACY_SIGNER_PRIVATE_KEY

操作流程：

1. 提示输入 GPG 密码（或从 OPENCLAW_GPG_PASSPHRASE 环境变量读取）
2. 从 .env 文件中提取指定密钥值
3. 将其加密后存储至 ~/.openclaw/.env.secrets.gpg（AES256 加密，权限 600）
4. 将 .env 中的原始值替换为 GPG:KEY_NAME 占位符
5. 使用 get_credential() 或 _load_cred() 的脚本将透明解密

**将密码保存至 .env 以支持自动化解密：**

echo 'OPENCLAW_GPG_PASSPHRASE=your-passphrase-here' >> ~/.openclaw/.env
chmod 600 ~/.openclaw/.env

验证加密结果：

# 检查 .env 是否包含 GPG 占位符
grep "GPG:" ~/.openclaw/.env

# 列出所有已加密的密钥
./scripts/encrypt.py --list

步骤 5：初始化轮换追踪

./scripts/rotation-check.py --init

自动按风险等级分类所有密钥：

• 关键级（每 90 天轮换）：*PRIVATE_KEY、*MNEMONIC、*SEED、*WALLET_KEY、*CUSTODY*、*SIGNER*
• 标准级（每 180 天轮换）：*API_KEY、*SECRET、*TOKEN、*BEARER、*CONSUMER*、*ACCESS*
• 低风险级（每 365 天轮换）：其余所有字段

生成 ~/.openclaw/.env.meta（权限 600），记录密钥创建时间与轮换计划。

随时检查轮换状态：

./scripts/rotation-check.py

步骤 6：清理旧凭据文件

# 先进行预览运行 —— 查看将被删除的文件
./scripts/cleanup.py

# 实际删除（会提示输入 'DELETE' 确认）
./scripts/cleanup.py --confirm

同时手动移除未被扫描器识别的迁移文件：

# 示例：farcaster-credentials.json 已手动迁移
cp ~/.openclaw/farcaster-credentials.json ~/.openclaw/backups/credentials-old-YYYYMMDD/farcaster-credentials.json.bak
chmod 600 ~/.openclaw/backups/credentials-old-YYYYMMDD/farcaster-credentials.json.bak
rm ~/.openclaw/farcaster-credentials.json

步骤 7：更新引用旧文件的脚本

所有曾从 JSON 凭据文件或硬编码路径加载数据的脚本均需更新。

模式 —— Bash 脚本示例：

# 旧版本（不安全）：
FARCASTER_CREDS="/home/user/.openclaw/farcaster-credentials.json"
fid=$(jq -r '.fid' "$FARCASTER_CREDS")
private_key=$(jq -r '.custodyPrivateKey' "$FARCASTER_CREDS")

# 新版本（安全，支持 GPG 解密）：
ENV_FILE="$HOME/.openclaw/.env"

_load_cred() {
  local key="$1"
  local value
  value=$(grep "^${key}=" "$ENV_FILE" | head -1 | cut -d= -f2-)
  if [[ "$value" == GPG:* ]]; then
    local gpg_key="${value#GPG:}"
    local passphrase="${OPENCLAW_GPG_PASSPHRASE:-}"
    if [ -n "$passphrase" ]; then
      value=$(echo "$passphrase" | gpg -d --batch --quiet --passphrase-fd 0 "$HOME/.openclaw/.env.secrets.gpg" | python3 -c "import json,sys; print(json.load(sys.stdin).get('$gpg_key',''))")
    else
      value=$(gpg -d --batch --quiet "$HOME/.openclaw/.env.secrets.gpg" | python3 -c "import json,sys; print(json.load(sys.stdin).get('$gpg_key',''))")
    fi
  fi
  echo "$value"
}

fid=$(_load_cred "FARCASTER_FID")
private_key=$(_load_cred "FARCASTER_CUSTODY_PRIVATE_KEY")

模式 — Node.js 脚本：

// 旧版（不安全）：
const creds = JSON.parse(fs.readFileSync('~/.openclaw/farcaster-credentials.json'));
const privateKey = creds.custodyPrivateKey;

// 新版（安全，支持 GPG）：
const ENV_PATH = path.join(os.homedir(), '.openclaw/.env');
const SECRETS_PATH = path.join(os.homedir(), '.openclaw/.env.secrets.gpg');

function loadCred(key) {
  const content = fs.readFileSync(ENV_PATH, 'utf8');
  for (const line of content.split('\n')) {
    if (line.startsWith(key + '=')) {
      let value = line.slice(key.length + 1).trim();
      if (value.startsWith('GPG:')) {
        const { execSync } = require('child_process');
        const passphrase = process.env.OPENCLAW_GPG_PASSPHRASE || '';
        const cmd = passphrase
          ? `echo "${passphrase}" | gpg -d --batch --quiet --passphrase-fd 0 "${SECRETS_PATH}"`
          : `gpg -d --batch --quiet "${SECRETS_PATH}"`;
        const secrets = JSON.parse(execSync(cmd, { encoding: 'utf8' }));
        return secrets[value.slice(4)] || '';
      }
      return value;
    }
  }
  return '';
}

const privateKey = loadCred('FARCASTER_CUSTODY_PRIVATE_KEY');

模式 — Python 脚本：

# 推荐使用 enforce 模块：
import sys
from pathlib import Path
sys.path.insert(0, str(Path.home() / 'openclaw/skills/credential-manager/scripts'))
from enforce import get_credential

private_key = get_credential('FARCASTER_CUSTODY_PRIVATE_KEY')  # 自动解密 GPG 加密内容

步骤 8：最终验证

# 运行完整验证 —— 应显示全部绿色
./scripts/validate.py

# 验证加密密钥
./scripts/encrypt.py --list

# 检查轮换状态
./scripts/rotation-check.py

# 测试使用凭证的脚本
bash /path/to/your/script.sh

预期最终状态：

~/.openclaw/
├── .env                     # 所有凭证（权限 600，私钥字段以 GPG:* 开头）
├── .env.secrets.gpg         # GPG 加密的私钥（权限 600）
├── .env.meta                # 轮换状态追踪元数据（权限 600）
├── .env.example             # 模板文件（可安全共享）
├── .gitignore               # 保护 .env、.env.secrets.gpg、.env.meta 文件
└── backups/                 # （权限 700）
    └── credentials-old-YYYYMMDD/  # （权限 700）
        └── *.bak            # 备份文件（权限 600）

为技能开发者：强制执行此标准

其他 OpenClaw 技能在使用凭证前必须验证其安全性：

Python 技能

#!/usr/bin/env python3
import sys
from pathlib import Path

# 将 credential-manager 脚本路径加入系统路径
sys.path.insert(0, str(Path.home() / '.openclaw/skills/credential-manager/scripts'))

# 强制检查 .env 安全性（不符合则退出）
from enforce import require_secure_env, get_credential

require_secure_env()

# 现在可安全加载凭证（自动处理 GPG 加密密钥）
api_key = get_credential('SERVICE_API_KEY')
wallet_key = get_credential('MAIN_WALLET_PRIVATE_KEY')  # 自动从 GPG 解密

Bash 技能

#!/usr/bin/env bash
set -euo pipefail

# 验证 .env 存在且安全
if ! python3 ~/.openclaw/skills/credential-manager/scripts/enforce.py; then
    exit 1
fi

# 现在可安全加载
source ~/.openclaw/.env

这构建了一个快速失败机制： 若凭证未正确保护，技能将拒绝运行。用户被迫修复问题。

加载凭证

迁移完成后，从 .env 文件加载：

Python

import os
from pathlib import Path

# 加载 .env 文件
env_file = Path.home() / '.openclaw' / '.env'
with open(env_file) as f:
    for line in f:
        if '=' in line and not line.strip().startswith('#'):
            key, val = line.strip().split('=', 1)
            os.environ[key] = val

# 使用凭证
api_key = os.getenv('SERVICE_API_KEY')

Bash

# 加载 .env
set -a
source ~/.openclaw/.env
set +a

# 使用凭证
echo "$SERVICE_API_KEY"

使用现有加载器

如果通过 OpenClaw 脚本完成迁移：

from load_credentials import get_credentials
creds = get_credentials('x')

添加新凭证

编辑 ~/.openclaw/.env：

# 添加新服务
NEW_SERVICE_API_KEY=your_key_here
NEW_SERVICE_SECRET=your_secret_here

同时更新模板文件：

# 编辑 .env.example
NEW_SERVICE_API_KEY=your_key_here
NEW_SERVICE_SECRET=your_secret_here

若新增凭证为高价值信息（如私钥、钱包密钥）：

# 先添加到 .env，再进行加密
./scripts/encrypt.py --keys NEW_SERVICE_PRIVATE_KEY

安全最佳实践

详见 [references/security.md](references/security.md) 获取详细安全指南。

快速检查清单：

• ✅ .env 文件权限为 600
• ✅ .env 已被 git 忽略
• ✅ 备份文件权限为 600
• ✅ 备份目录权限为 700
• ✅ 代码或日志中无凭证（使用 --deep 扫描验证）
• ✅ 私钥已使用 GPG 加密
• ✅ 建立并跟踪轮换计划
• ✅ 符号链接指向主 .env 文件
• ✅ 无凭证记录在 shell 历史中（避免使用 export KEY=val，应使用 source）

回滚操作

如出现问题：

# 查找备份文件
ls -la ~/.openclaw/backups/

# 恢复特定文件
cp ~/.openclaw/backups/credentials-old-YYYYMMDD/x-credentials.json.bak \
   ~/.config/x/credentials.json

# 将 GPG 加密的密钥解密回明文
./scripts/encrypt.py --decrypt --keys MAIN_WALLET_PRIVATE_KEY

注意事项

• 默认非破坏性： 删除前会备份原始文件
• 幂等性： 可多次安全运行
• 可扩展： 可在脚本中添加自定义凭证模式
• 安全性： 不记录完整凭证，仅记录元数据
• GPG 友好： 透明处理加密与明文凭证
• 备份强化： 所有备份均设置正确权限
• 符号链接感知： 能检测并验证符号链接的凭证文件