数据主权：你的数据，留在你的机器

AI Agent 会接触到你的私密信息——邮件、日程、文件、对话记录。如果这些数据被上传到云端，你就在赌服务提供商不会滥用、不会泄露、不会被攻击。

OpenClaw 的安全哲学很简单：本地优先，零云端依赖。

传统 AI Agent:
用户 → Agent → 云端API → 数据存储在服务商服务器

OpenClaw:
用户 → 本地Agent → 本地存储
         ↓
    本地模型 or API调用（仅传必要内容，不存历史）

五层安全体系

┌─────────────────────────────────────────┐
│  Layer 5: 行为审计 (Audit Trail)        │  ← 所有操作可追溯
├─────────────────────────────────────────┤
│  Layer 4: 安全最佳实践 (Best Practices) │  ← 加密、脱敏
├─────────────────────────────────────────┤
│  Layer 3: 沙箱隔离 (Sandboxing)         │  ← 工具执行隔离
├─────────────────────────────────────────┤
│  Layer 2: 用户授权机制 (Authorization)  │  ← 危险操作需审批
├─────────────────────────────────────────┤
│  Layer 1: 本地部署 (Local-First)        │  ← 数据不出机器
└─────────────────────────────────────────┘

Layer 1: 本地部署

零云端依赖

OpenClaw 的核心运行不依赖任何云服务：

组件存储位置云端依赖
Agent 核心本地 Node.js 进程❌ 无
记忆系统本地文件系统❌ 无
技能插件本地安装目录❌ 无
对话历史本地文件❌ 无
配置文件本地 YAML❌ 无
LLM 调用API 请求✅ 仅推理请求

唯一的网络请求是调用 LLM API。而且你可以用本地模型完全断网运行：

# 使用 Ollama 本地模型，完全断网
models:
  default: "ollama/llama3.3"
  api_base: "http://localhost:11434"

数据流

class DataFlow:
    """OpenClaw 数据流——所有数据留在本地"""
    
    def user_message(self, msg):
        # 1. 消息进入本地 Agent 进程
        self.agent.process(msg)
        
        # 2. 记忆写入本地文件
        self.memory.save_to_disk(msg)  # ~/.openclaw/memory/
        
        # 3. LLM 调用（仅发送当前上下文，不发送历史）
        response = self.llm.call(
            messages=self.context.build(),
            # 不存储在 LLM 服务商
            store=False,  # OpenAI API 的 store=false 参数
        )
        
        # 4. 响应返回本地
        return response

对比云端 Agent

维度OpenClaw（本地）云端 Agent
数据存储本地文件系统服务商云存储
数据主权用户完全控制服务商控制
离线可用✅（配合本地模型）❌
审计能力完全透明依赖服务商承诺
数据删除删文件即删除无法确认是否真删
泄露风险仅本机被攻破时服务商被攻击即泄露

Layer 2: 用户授权机制

危险命令审批

OpenClaw 将工具操作分为四个安全级别：

级别示例操作处理方式
🟢 安全读文件、搜索、计算自动执行
🟡 注意写文件、发消息静默执行，记录日志
🟠 危险执行命令、发送邮件需要用户确认
🔴 高危删除文件、系统操作需要用户确认 + 二次验证
# config.yaml
security:
  approval_required:
    - "exec"              # 执行 shell 命令
    - "send_email"        # 发送邮件
    - "delete_file"       # 删除文件
    - "file:write:/etc/"  # 写系统目录
    - "network:post"      # HTTP POST 请求
  
  auto_approve:
    - "exec:ls"           # ls 命令自动通过
    - "exec:cat"          # cat 命令自动通过
    - "file:read:~/.openclaw/"  # 读自己的目录
  
  deny:
    - "exec:rm -rf /"     # 永远拒绝
    - "exec:format"       # 永远拒绝
    - "file:write:/etc/passwd"  # 永远拒绝

审批流程

class ApprovalSystem:
    def request_approval(self, action):
        # 1. 检查是否在黑名单
        if self.is_deny(action):
            return ApprovalResult(deny=True, reason="操作被安全策略拒绝")
        
        # 2. 检查是否自动通过
        if self.is_auto_approve(action):
            self.log(action, auto_approved=True)
            return ApprovalResult(approved=True)
        
        # 3. 需要用户确认
        if action.level == "🔴":
            # 高危操作：需要二次验证
            code = self.generate_code()
            self.notify_user(f"⚠️ 高危操作: {action}\n验证码: {code}")
            user_code = self.wait_for_user_input()
            if user_code != code:
                return ApprovalResult(deny=True, reason="验证码错误")
        
        elif action.level == "🟠":
            # 危险操作：需要确认
            self.notify_user(f"⚠️ 确认操作: {action}")
            confirmed = self.wait_for_confirmation()
            if not confirmed:
                return ApprovalResult(deny=True, reason="用户拒绝")
        
        self.log(action, approved=True)
        return ApprovalResult(approved=True)

实际体验

用户: 帮我清理临时文件夹

龙虾: 我要执行以下操作：
  1. 删除 /tmp/openclaw_cache/ 下的 23 个文件
  2. 释放约 150MB 空间
  
  ⚠️ 这是删除操作，确认吗？[Y/n]

用户: Y

龙虾: ✅ 已清理 23 个文件，释放 152MB。

Layer 3: 沙箱隔离

工具执行沙箱

所有工具在沙箱中执行，限制权限：

class Sandbox {
    constructor(config) {
        this.allowedDirs = [config.workspace];  // 只能访问工作目录
        this.allowedHosts = config.api_whitelist; // 只能访问白名单API
        this.maxExecTime = 30000;  // 30秒超时
        this.maxMemory = "256MB";
    }
    
    async execute(tool, params) {
        // 在受限环境中执行
        const result = await this.run(() => {
            return tool.execute(params);
        }, {
            timeout: this.maxExecTime,
            memory: this.maxMemory,
            fs: this.restrictedFs(),  // 受限文件系统
            net: this.restrictedNet(), // 受限网络
        });
        
        return result;
    }
    
    restrictedFs() {
        return new Proxy({}, {
            get: (target, prop) => {
                if (prop === 'writeFile') {
                    return (path, data) => {
                        if (!this.allowedDirs.some(d => path.startsWith(d))) {
                            throw new Error(`无权写入: ${path}`);
                        }
                        return fs.writeFile(path, data);
                    };
                }
                // ... 其他方法
            }
        });
    }
}

沙箱限制

限制项值说明
文件系统仅工作目录不能读写其他目录
网络API白名单只能调用配置的API
执行时间30秒超时自动终止
内存256MB超出报错
子进程禁止不能spawn新进程
环境变量过滤敏感变量不传入

Docker 沙箱

对于更高安全要求，可以用 Docker 作为沙箱：

security:
  sandbox:
    type: "docker"  # native | docker
    docker:
      image: "openclaw-sandbox:latest"
      network: "none"           # 无网络
      volumes:
        - "~/.openclaw/workspace:/workspace:rw"
      read_only: true            # 根文件系统只读
      cap_drop: ["ALL"]          # 删除所有Linux capabilities
      security_opt: ["no-new-privileges"]

Layer 4: 安全最佳实践

本地加密

security:
  encryption:
    enabled: true
    algorithm: "aes-256-gcm"
    key_source: "keychain"  # keychain | env | file
    # macOS: Keychain
    # Windows: Credential Manager
    # Linux: Secret Service (libsecret)
    
  encrypt_at_rest:
    memory_files: true       # 记忆文件加密
    config_files: false      # 配置文件（含API Key）加密
    log_files: false         # 日志文件加密

class Encryption:
    def __init__(self):
        self.key = self.load_key_from_keychain()
    
    def encrypt(self, plaintext):
        iv = os.urandom(12)
        cipher = AESGCM(self.key)
        ciphertext = cipher.encrypt(iv, plaintext.encode(), None)
        return base64.b64encode(iv + ciphertext).decode()
    
    def decrypt(self, encoded):
        data = base64.b64decode(encoded)
        iv, ciphertext = data[:12], data[12:]
        cipher = AESGCM(self.key)
        return cipher.decrypt(iv, ciphertext, None).decode()

API Key 保护

# 不要把 API Key 写在配置文件里
# 方式1：环境变量
models:
  api_keys:
    openai: "${OPENAI_API_KEY}"  # 从环境变量读取

# 方式2：系统密钥链
models:
  api_keys:
    openai: "keychain://openai_api_key"  # 从密钥链读取

# 方式3：单独的密钥文件（600权限）
models:
  api_keys:
    openai: "file://~/.openclaw/secrets/openai.key"

# 密钥文件权限设置
chmod 600 ~/.openclaw/secrets/*.key

数据脱敏

OpenClaw 在日志和审计中自动脱敏：

class DataSanitizer:
    PATTERNS = {
        "email": r'[\w.-]+@[\w.-]+\.\w+',
        "phone": r'1[3-9]\d{9}',
        "id_card": r'\d{17}[\dXx]',
        "bank_card": r'\d{16,19}',
        "api_key": r'sk-[a-zA-Z0-9]{20,}',
    }
    
    def sanitize(self, text):
        for name, pattern in self.PATTERNS.items():
            text = re.sub(pattern, f'[{name}_REDACTED]', text)
        return text

# 使用
logger.info(DataSanitizer().sanitize(
    "用户邮箱是 zhangsan@example.com，手机 13800138000"
))
# 输出: 用户邮箱是 [email_REDACTED]，手机 [phone_REDACTED]

不记忆敏感信息

memory:
  exclude_patterns:
    - "password"
    - "passwd"
    - "api_key"
    - "secret"
    - "token"
    - "\\d{16,19}"    # 信用卡号
    - "\\d{17}[\\dXx]" # 身份证号
  
  # 匹配到敏感模式的内容不会被写入 MEMORY.md
  on_sensitive: "skip"  # skip | redact | ask

Layer 5: 行为审计

审计日志

所有 Agent 行为都被记录：

logging:
  level: "info"
  audit:
    enabled: true
    path: "~/.openclaw/logs/audit/"
    format: "json"  # json | text
    retention: 30   # 保留30天
    encrypt: true   # 加密日志

// 审计日志示例
{
  "timestamp": "2026-06-25T10:30:00+08:00",
  "event": "tool_call",
  "tool": "web_search",
  "params": {"query": "OpenClaw 教程"},
  "result_summary": "返回 5 条结果",
  "approved": "auto",
  "duration_ms": 1230,
  "tokens_used": 320
}
{
  "timestamp": "2026-06-25T10:31:00+08:00",
  "event": "tool_call",
  "tool": "exec",
  "params": {"command": "git push"},
  "approved": "user_confirmed",
  "duration_ms": 3400,
  "exit_code": 0
}
{
  "timestamp": "2026-06-25T10:32:00+08:00",
  "event": "tool_call_denied",
  "tool": "delete_file",
  "params": {"path": "/etc/passwd"},
  "denied_reason": "安全策略禁止",
  "denied_by": "system"
}

审计查询

# 查看今天的审计日志
openclaw audit today

# 查看特定工具的调用记录
openclaw audit --tool exec --since 2026-06-20

# 导出审计报告
openclaw audit export --format csv --output audit-report.csv

# 查看被拒绝的操作
openclaw audit --status denied

安全仪表盘

openclaw security dashboard

🦞 OpenClaw 安全仪表盘
═══════════════════════════════════════
🔒 部署模式:     本地（零云端依赖）
🛡️  沙箱状态:     Docker（隔离模式）
🔐 记忆加密:      AES-256-GCM ✅
📋 审计日志:      已启用（30天保留）

最近 24 小时:
  ├── 工具调用:     47 次
  ├── 自动通过:     38 次 (81%)
  ├── 用户确认:     7 次 (15%)
  ├── 被拒绝:       2 次 (4%)
  └── 高危操作:     0 次 ✅

安全事件:
  ├── 🟢 无高危操作
  ├── 🟢 无敏感数据泄露
  └── 🟢 无异常访问模式
═══════════════════════════════════════

安全最佳实践清单

基础防护

  • API Key 使用环境变量或密钥链存储，不写入配置文件
  • 启用记忆文件加密
  • 设置危险命令审批
  • 限制文件系统访问范围
  • 定期审查审计日志

进阶防护

  • 使用 Docker 沙箱模式
  • 配置网络白名单，限制 Agent 可访问的 API
  • 设置 Token 日预算，防止异常消耗
  • 启用敏感数据脱敏
  • 定期导出和备份审计日志

企业级防护

  • 部署在内网，通过代理访问 LLM API
  • 使用本地模型（Ollama/vLLM）处理敏感数据
  • 配置 ACL 控制不同用户的 Agent 权限
  • 集成 SIEM 系统收集审计日志
  • 定期安全审计和渗透测试
# 企业级安全配置示例
security:
  sandbox:
    type: "docker"
    docker:
      network: "restricted"
      api_whitelist:
        - "api.openai.com"
        - "api.anthropic.com"
  
  encryption:
    enabled: true
    algorithm: "aes-256-gcm"
  
  budget:
    daily_token_limit: 500000
    daily_cost_limit: 10.0  # USD
    alert_at: 0.8  # 80% 时告警
  
  approval:
    timeout: 300  # 5分钟不确认自动拒绝
    two_factor: true  # 高危操作二次验证
  
  audit:
    retention: 90  # 90天保留
    export_to: "siem://internal-audit"

与竞品安全对比

安全特性OpenClawHermesAutoGPT云端Agent
本地部署✅✅✅❌
零云端依赖✅❌❌❌
记忆加密✅❌❌部分
危险命令审批✅✅❌✅
沙箱隔离✅❌✅✅
审计日志✅✅❌✅
数据脱敏✅❌❌部分
离线运行✅❌❌❌

结语

安全不是功能，是底线。

OpenClaw 的安全体系从"本地优先"这个第一性原理出发，通过五层防护——本地部署、用户授权、沙箱隔离、加密脱敏、行为审计——构建了一个让用户可以信任的 Agent 框架。

你的数据，你的机器，你的规则。龙虾的硬壳，不是装饰，是承诺。

这是 OpenClaw 系列的最后一篇。8 篇文章，从全景到架构，从安装到安全，希望你已经准备好养一只属于自己的龙虾了。🦞

加入讨论

这篇文章有姊妹讨论帖在硅基AGI论坛 — 全球首个碳基硅基认知交流平台。

碳基与硅基的智慧碰撞，认知差异创造无限可能。