🛡️ OPENCLAW SECURITY SERIES

OPENCLAW SECURITY GUIDE

OpenClaw安全加固实战指南

bash

#!/bin/bash
# openclaw-firewall.sh - OpenClaw防火墙配置脚本

# 清空现有规则
iptables -F
iptables -X
iptables -Z

# 默认策略：拒绝所有入站，允许所有出站
iptables -P INPUT DROP
iptables -P OUTPUT ACCEPT
iptables -P FORWARD DROP

# 允许本地回环
iptables -A INPUT -i lo -j ACCEPT
iptables -A OUTPUT -o lo -j ACCEPT

# 允许已建立的连接
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# 允许SSH（仅允许公司IP段）
iptables -A INPUT -p tcp -s 192.168.1.0/24 --dport 22 -j ACCEPT

# 允许HTTP/HTTPS（仅允许CDN/WAF节点）
iptables -A INPUT -p tcp -s 103.21.244.0/22 --dport 80 -j ACCEPT
iptables -A INPUT -p tcp -s 103.21.244.0/22 --dport 443 -j ACCEPT

# OpenClaw Gateway管理端口（仅允许内网）
iptables -A INPUT -p tcp -s 172.16.0.0/12 --dport 8080 -j ACCEPT

# Agent通信端口（仅允许内网）
iptables -A INPUT -p tcp -s 172.16.0.0/12 --dport 9000:9010 -j ACCEPT

# 记录拒绝的连接
iptables -A INPUT -j LOG --log-prefix "iptables-denied: " --log-level 4

# 保存规则
netfilter-persistent save

yaml

version: '3.8'

networks:
  dmz:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.1.0/24
  app:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.2.0/24
  data:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.3.0/24
    internal: true  # 内部网络，不可访问外网

services:
  nginx:
    image: nginx:alpine
    networks:
      - dmz
      - app
    ports:
      - "80:80"
      - "443:443"
    depends_on:
      - gateway

  gateway:
    image: openclaw/gateway:latest
    networks:
      - app
      - data
    environment:
      - OPENCLAW_SECURITY_ENABLED=true
    expose:
      - "8080"
    depends_on:
      - redis
      - postgres

  agent-runtime:
    image: openclaw/agent:latest
    networks:
      - app
      - data
    deploy:
      replicas: 3

  redis:
    image: redis:7-alpine
    networks:
      - data
    command: redis-server --requirepass ${REDIS_PASSWORD}

  postgres:
    image: postgres:15-alpine
    networks:
      - data
    environment:
      - POSTGRES_PASSWORD=${DB_PASSWORD}

hcl

resource "aws_security_group" "openclaw_dmz" {
  name        = "openclaw-dmz"
  description = "OpenClaw DMZ Security Group"

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["192.168.1.0/24"]  # 仅公司VPN
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "openclaw-dmz"
  }
}

resource "aws_security_group" "openclaw_internal" {
  name        = "openclaw-internal"
  description = "OpenClaw Internal Services Security Group"

  ingress {
    from_port       = 8080
    to_port         = 8080
    protocol        = "tcp"
    security_groups = [aws_security_group.openclaw_dmz.id]
  }

  tags = {
    Name = "openclaw-internal"
  }
}

yaml

# openclaw-security.yaml
security:
  enabled: true
  
  jwt:
    issuer: "openclaw-gateway"
    audience: "openclaw-agents"
    accessTokenExpiry: "15m"
    refreshTokenExpiry: "7d"
    algorithm: "RS256"  # 使用非对称加密
    publicKeyPath: "/etc/openclaw/certs/jwt_public.pem"
    privateKeyPath: "/etc/openclaw/certs/jwt_private.pem"
  
  rbac:
    enabled: true
    policyFile: "/etc/openclaw/rbac/policy.csv"
    modelFile: "/etc/openclaw/rbac/model.conf"
  
  rateLimit:
    enabled: true
    requestsPerMinute: 100
    burst: 50

ini

# model.conf - Casbin RBAC模型
[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[role_definition]
g = _, _

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

csv

# policy.csv - RBAC策略定义
p, admin, sessions, create
p, admin, sessions, read
p, admin, sessions, update
p, admin, sessions, delete
p, admin, agents, *
p, admin, users, *

p, operator, sessions, read
p, operator, sessions, create
p, operator, agents, read

p, viewer, sessions, read
p, viewer, agents, read

# 角色分配（示例，使用实际用户ID替换）
g, <admin_user_id>, admin
g, <operator_user_id>, operator
g, <viewer_user_id>, viewer

javascript

// jwt-middleware.js
const jwt = require('jsonwebtoken');
const fs = require('fs');
const publicKey = fs.readFileSync('/etc/openclaw/certs/jwt_public.pem');

const authMiddleware = (req, res, next) => {
  try {
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({ error: '未提供认证令牌' });
    }

    const token = authHeader.substring(7);
    const decoded = jwt.verify(token, publicKey, {
      algorithms: ['RS256'],
      issuer: 'openclaw-gateway',
      audience: 'openclaw-agents'
    });

    req.user = decoded;
    next();
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({ error: '令牌已过期', code: 'TOKEN_EXPIRED' });
    }
    return res.status(401).json({ error: '无效的认证令牌' });
  }
};

// RBAC权限检查中间件
const rbacMiddleware = (requiredPermission) => {
  return (req, res, next) => {
    const userRoles = req.user.roles || [];
    const [resource, action] = requiredPermission.split(':');
    
    // 这里调用Casbin进行权限检查
    const hasPermission = checkPermission(userRoles, resource, action);
    
    if (!hasPermission) {
      return res.status(403).json({ 
        error: '权限不足',
        required: requiredPermission 
      });
    }
    
    next();
  };
};

// 使用示例
app.get('/api/sessions', 
  authMiddleware, 
  rbacMiddleware('sessions:read'),
  (req, res) => {
    // 处理请求
  }
);

bash

#!/bin/bash
# rotate-jwt-keys.sh - JWT密钥轮换脚本

KEY_DIR="/etc/openclaw/certs"
DATE=$(date +%Y%m%d_%H%M%S)

# 备份旧密钥
if [ -f "$KEY_DIR/jwt_private.pem" ]; then
  mv "$KEY_DIR/jwt_private.pem" "$KEY_DIR/jwt_private.pem.$DATE.bak"
  mv "$KEY_DIR/jwt_public.pem" "$KEY_DIR/jwt_public.pem.$DATE.bak"
fi

# 生成新的RSA密钥对
openssl genrsa -out "$KEY_DIR/jwt_private.pem" 4096
openssl rsa -in "$KEY_DIR/jwt_private.pem" -pubout -out "$KEY_DIR/jwt_public.pem"

# 设置权限
chmod 600 "$KEY_DIR/jwt_private.pem"
chmod 644 "$KEY_DIR/jwt_public.pem"

# 重启服务
systemctl reload openclaw-gateway

echo "JWT密钥轮换完成：$DATE"

nginx

# /etc/nginx/conf.d/openclaw.conf
server {
    listen 443 ssl http2;
    server_name openclaw.example.com;

    # SSL/TLS安全配置
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1h;

    # HTTP安全头
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
    add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';" always;
    add_header Permissions-Policy "geolocation=(), microphone=(), camera=()" always;

    # 速率限制（防暴力破解）
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;
    limit_req zone=api_limit burst=20 nodelay;

    # 连接限制
    limit_conn_zone $binary_remote_addr zone=conn_limit:10m;
    limit_conn conn_limit 50;

    # 请求大小限制
    client_max_body_size 10M;
    client_body_buffer_size 128k;

    # 超时设置（防Slowloris攻击）
    client_body_timeout 10s;
    client_header_timeout 10s;
    keepalive_timeout 5s;
    send_timeout 10s;

    location / {
        proxy_pass http://openclaw_gateway;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # 拒绝访问隐藏文件
    location ~ /\. {
        deny all;
        access_log off;
        log_not_found off;
    }
}

nginx

# /etc/nginx/modsecurity/openclaw.conf
SecRuleEngine On
SecRequestBodyAccess On
SecResponseBodyAccess Off

# 请求体限制
SecRequestBodyLimit 13107200
SecRequestBodyNoFilesLimit 131072

# 启用核心规则集
Include /usr/share/modsecurity-crs/crs-setup.conf
Include /usr/share/modsecurity-crs/rules/*.conf

# OpenClaw自定义规则
SecRule ARGS:session_id "@rx ^[a-zA-Z0-9-]{36}$" \
    "phase:2,block,status:403,msg:'Invalid session ID format'"

SecRule REQUEST_URI "@rx (?:\.\./|/\./)" \
    "phase:2,block,status:403,msg:'Path traversal attempt'"

SecRule REQUEST_HEADERS:User-Agent "@pm crawler scanner bot" \
    "phase:1,pass,tag:'suspected-bot'"

# SQL注入防护
SecRule ARGS "@rx (?i:(select|union|insert|update|delete|drop|--))" \
    "phase:2,block,status:403,msg:'SQL injection attempt'"

# XSS防护
SecRule ARGS "@rx (?i:(<script|javascript:|onerror=|onload=))" \
    "phase:2,block,status:403,msg:'XSS attack attempt'"

javascript

// rate-limiter.js - 分布式速率限制
const redis = require('redis');
const client = redis.createClient();

class RateLimiter {
  constructor(options = {}) {
    this.windowMs = options.windowMs || 60000;  // 默认1分钟
    this.maxRequests = options.maxRequests || 100;
    this.prefix = options.prefix || 'ratelimit:';
  }

  async isAllowed(identifier) {
    const key = `${this.prefix}${identifier}`;
    const now = Date.now();
    const windowStart = now - this.windowMs;

    // 移除时间窗口外的记录
    await client.zRemRangeByScore(key, 0, windowStart);
    
    // 获取当前请求数
    const requestCount = await client.zCard(key);
    
    if (requestCount >= this.maxRequests) {
      return { allowed: false, retryAfter: this.windowMs / 1000 };
    }

    // 记录新请求
    await client.zAdd(key, { score: now, value: now.toString() });
    await client.expire(key, Math.ceil(this.windowMs / 1000));

    return { 
      allowed: true, 
      remaining: this.maxRequests - requestCount - 1 
    };
  }
}

// 在OpenClaw Gateway中使用
const apiLimiter = new RateLimiter({
  windowMs: 60000,
  maxRequests: 100,
  prefix: 'openclaw:api:'
});

const authLimiter = new RateLimiter({
  windowMs: 300000,  // 5分钟
  maxRequests: 5,    // 最多5次登录尝试
  prefix: 'openclaw:auth:'
});

app.post('/api/auth/login', async (req, res, next) => {
  const result = await authLimiter.isAllowed(req.ip);
  if (!result.allowed) {
    return res.status(429).json({
      error: '登录尝试过于频繁',
      retryAfter: result.retryAfter
    });
  }
  next();
});

hcl

# Cloudflare WAF配置（Terraform）
resource "cloudflare_firewall_rule" "openclaw_ddos" {
  zone_id = var.zone_id
  action  = "managed_challenge"
  
  filter {
    expression = "(http.request.uri.path contains \"/api/\" and cf.threat_score gt 10)"
    description = "Challenge high threat score API requests"
  }
}

resource "cloudflare_rate_limit" "openclaw_api" {
  zone_id     = var.zone_id
  match {
    request {
      url_pattern = "openclaw.example.com/api/*"
      scheme      = "HTTPS"
      method      = "ALL"
    }
  }
  
  threshold = 100
  period    = 60
  action {
    mode = "simulate"  # 测试时用simulate，生产改为block
    timeout = 300
  }
}

nginx

# nginx-tls.conf - TLS 1.3强加密配置
server {
    listen 443 ssl http2;
    server_name openclaw.example.com;

    # 证书路径
    ssl_certificate /etc/letsencrypt/live/openclaw.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/openclaw.example.com/privkey.pem;

    # TLS 1.3优先
    ssl_protocols TLSv1.3 TLSv1.2;
    ssl_prefer_server_ciphers on;
    ssl_ciphers TLS13-AES-256-GCM-SHA384:TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384;

    # HSTS（强制HTTPS）
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;

    # OCSP Stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_trusted_certificate /etc/letsencrypt/live/openclaw.example.com/chain.pem;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
}

sql

-- PostgreSQL透明数据加密配置
-- 创建加密表空间
CREATE TABLESPACE encrypted_ts
LOCATION '/var/lib/postgresql/15/main/encrypted'
WITH (encryption = 'on');

-- 创建加密数据库
CREATE DATABASE openclaw_prod
TABLESPACE = encrypted_ts;

-- 列级加密示例
CREATE EXTENSION pgcrypto;

CREATE TABLE credentials (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    agent_id UUID NOT NULL,
    -- 使用pgcrypto加密敏感字段
    api_key BYTEA NOT NULL,
    api_secret BYTEA NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

-- 插入加密数据
INSERT INTO credentials (agent_id, api_key, api_secret)
VALUES (
    '550e8400-e29b-41d4-a716-446655440000',
    pgp_sym_encrypt('sk_live_12345', ${DB_ENCRYPTION_KEY}, 'cipher-algo=aes256'),
    pgp_sym_encrypt('secret_value', ${DB_ENCRYPTION_KEY}, 'cipher-algo=aes256')
);

-- 查询解密数据
SELECT 
    id,
    agent_id,
    pgp_sym_decrypt(api_key, ${DB_ENCRYPTION_KEY}) as api_key,
    pgp_sym_decrypt(api_secret, ${DB_ENCRYPTION_KEY}) as api_secret
FROM credentials;

javascript

// vault-client.js - Vault凭证管理
const vault = require('node-vault');

class VaultSecretManager {
  constructor(options) {
    this.client = vault({
      apiVersion: 'v1',
      endpoint: options.endpoint || 'http://vault:8200',
      token: options.token
    });
  }

  // 获取密钥
  async getSecret(path) {
    try {
      const result = await this.client.read(`secret/data/openclaw/${path}`);
      return result.data.data;
    } catch (error) {
      console.error('Vault读取失败:', error);
      throw error;
    }
  }

  // 动态生成数据库凭证
  async getDatabaseCreds(role = 'openclaw-app') {
    const result = await this.client.read(`database/creds/${role}`);
    return {
      username: result.data.username,
      password: result.data.password,
      lease_id: result.lease_id,
      lease_duration: result.lease_duration
    };
  }

  // 加密数据
  async encrypt(plaintext, keyName = 'openclaw-key') {
    const result = await this.client.write(`transit/encrypt/${keyName}`, {
      plaintext: Buffer.from(plaintext).toString('base64')
    });
    return result.data.ciphertext;
  }

  // 解密数据
  async decrypt(ciphertext, keyName = 'openclaw-key') {
    const result = await this.client.write(`transit/decrypt/${keyName}`, {
      ciphertext: ciphertext
    });
    return Buffer.from(result.data.plaintext, 'base64').toString();
  }
}

// OpenClaw配置加密示例
// ⚠️ 安全提示：生产环境不应直接使用token参数
// 推荐使用Vault Agent、AppRole、Kubernetes Auth等方式认证
const vaultManager = new VaultSecretManager({ 
  // 生产环境建议：
  // 1. 使用Vault Agent Sidecar注入token
  // 2. 使用Kubernetes Service Account认证
  // 3. 使用AppRole+SecretID方式
  token: process.env.VAULT_TOKEN  // 仅用于开发演示
});

async function loadConfig() {
  // 从Vault获取所有敏感配置
  const secrets = await vaultManager.getSecret('production');
  
  return {
    database: await vaultManager.getDatabaseCreds(),
    jwt: {
      privateKey: await vaultManager.decrypt(secrets.jwt_private_key_encrypted)
    },
    openai: {
      apiKey: secrets.openai_api_key  // 直接从Vault获取
    }
  };
}

bash

# 初始化git-crypt
cd openclaw-config/
git-crypt init

# 创建.gitattributes指定加密文件
cat > .gitattributes << 'EOF'
*.env filter=git-crypt diff=git-crypt
*.key filter=git-crypt diff=git-crypt
secrets/** filter=git-crypt diff=git-crypt
EOF

# 添加GPG密钥
git-crypt add-gpg-user admin@example.com

# 正常提交（敏感文件自动加密）
git add .
git commit -m "Add encrypted config"
git push

# 解密查看
git-crypt unlock

yaml

# k8s-sealed-secrets.yaml
apiVersion: bitnami.com/v1alpha1
kind: SealedSecret
metadata:
  name: openclaw-secrets
  namespace: openclaw
spec:
  encryptedData:
    # 这些值由kubeseal加密生成
    DB_PASSWORD: AgC...<long-encrypted-string>
    JWT_SECRET: AgB...<long-encrypted-string>
    OPENAI_API_KEY: AgD...<long-encrypted-string>
  template:
    metadata:
      name: openclaw-secrets
      namespace: openclaw
    type: Opaque
---
# 使用SealedSecret的Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: openclaw-gateway
spec:
  template:
    spec:
      containers:
      - name: gateway
        image: openclaw/gateway:latest
        env:
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: openclaw-secrets
              key: DB_PASSWORD
        - name: JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: openclaw-secrets
              key: JWT_SECRET

yaml

# openclaw-audit.yaml
audit:
  enabled: true
  output: "file,syslog,http"
  filePath: "/var/log/openclaw/audit.json"
  syslog:
    host: "siem.example.com"
    port: 514
  http:
    endpoint: "https://siem.example.com/webhook"
    headers:
      Authorization: "Bearer ${SIEM_TOKEN}"

  events:
    - authentication
    - authorization
    - session_create
    - session_delete
    - secret_access
    - config_change
    - api_rate_limit_exceeded

markdown

# OpenClaw安全事件应急响应检查清单

## 1. 事件确认阶段
- [ ] 确认安全事件真实性
- [ ] 评估影响范围（用户数、数据量）
- [ ] 记录事件时间线
- [ ] 通知相关人员

## 2. 遏制阶段
- [ ] 隔离受影响系统
- [ ] 撤销可疑凭证
- [ ] 阻断攻击源IP
- [ ] 启动备用系统

## 3. 根除阶段
- [ ] 识别攻击入口
- [ ] 修复安全漏洞
- [ ] 清除恶意代码
- [ ] 更新防护规则

## 4. 恢复阶段
- [ ] 从安全备份恢复数据
- [ ] 逐步恢复服务
- [ ] 加强监控力度
- [ ] 验证系统完整性

## 5. 复盘阶段
- [ ] 执行根因分析
- [ ] 更新安全策略
- [ ] 加固防护措施
- [ ] 培训相关人员

yaml

# openclaw-compliance-checklist.yaml
compliance:
  # 通用控制
  access_logging: true           # 所有访问操作必须记录
  encryption_required: true      # 敏感数据必须加密存储和传输
  least_privilege: true          # 遵循最小权限原则
  regular_audit: true            # 定期执行安全审计
  
  # GDPR特定要求
  data_portability: true         # 支持用户数据导出
  right_to_erasure: true         # 支持用户数据删除
  privacy_by_design: true        # 隐私保护嵌入设计流程
  
  # HIPAA特定要求
  access_review: "90d"           # 每90天审查用户访问权限
  audit_log_retention: "7y"      # 审计日志保留7年
  
  # PCI DSS特定要求
  key_rotation: "90d"            # 密钥每90天轮换
  vulnerability_scan: "quarterly" # 每季度漏洞扫描

yaml

# .github/workflows/compliance.yml - GitHub Actions合规检查
name: Compliance Scan

on: [push, pull_request]

jobs:
  compliance:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      # 基础设施即代码扫描
      - name: Checkov IaC扫描
        uses: bridgecrewio/checkov-action@v12
        with:
          directory: infrastructure/
          framework: terraform
          
      # 容器镜像漏洞扫描
      - name: Trivy镜像扫描
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: openclaw/gateway:latest
          format: sarif
          
      # 依赖漏洞扫描
      - name: OWASP Dependency-Check
        uses: dependency-check/Dependency-Check_Action@main
        with:
          project: 'openclaw'
          path: '.'
          format: 'JSON'