<!-- title: Claude Code沙箱隔离与DevContainer安全实战 -->

# Claude Code沙箱隔离与DevContainer安全实战

## 概述

本教程深入讲解Claude Code的三层安全隔离体系：内置沙箱（macOS Seatbelt / Linux namespace）、开发容器（DevContainer）隔离、以及网络防火墙配置。适合需要在CI/CD流水线、远程服务器、或处理不可信代码仓库场景下安全使用Claude Code的开发者。学完即可构建一套生产级的安全隔离开发环境。

**适用人群**：有Claude Code使用经验，关注安全隔离的DevOps工程师、安全工程师、团队技术负责人。

**学习目标**：
- 理解Claude Code三层沙箱架构的设计哲学
- 掌握macOS Seatbelt和Linux namespace两种沙箱的配置方法
- 从零搭建一个带网络隔离的DevContainer环境
- 配置iptables防火墙和白名单代理
- 在远程VPS上部署安全的Claude Code工作环境

## 前置条件

- Claude Code 已安装（`npm install -g @anthropic-ai/claude-code`）
- Docker Desktop 20.x+ 已安装并运行
- VS Code + Dev Containers 扩展（可选，纯终端亦可）
- 基础Linux网络知识（iptables、DNS）
- 一台远程Linux服务器（用于SSH实战部分）

---

## 第一层：Claude Code内置沙箱

### 1.1 沙箱架构总览

Claude Code从2025年末开始引入操作系统级沙箱机制，其核心思路是：**在用户确认之前，所有shell命令都在受限环境中执行**。这层防护不依赖Docker，而是直接调用操作系统内核的安全功能。


![图表1](images/claude-code-tutorial-r4-0119-mermaid-0.png)

> *图表 1*


**平台差异对照**：

| 特性 | macOS (Seatbelt) | Linux (Namespace+Landlock) |
|------|-------------------|---------------------------|
| 文件系统隔离 | sandbox-attack profile | mount namespace + landlock |
| 网络隔离 | network deny白名单 | network namespace |
| 进程隔离 | 进程信号限制 | PID namespace |
| 配置方式 | settings.json | settings.json |
| 性能开销 | 极低（内核级） | 极低（内核级） |
| 最低版本 | macOS 11+ | Kernel 5.13+（Landlock） |

### 1.2 macOS Seatbelt配置

macOS上Claude Code使用Apple的Seatbelt框架——与App Store应用沙箱相同的技术。默认情况下，沙箱限制所有文件写入和网络访问，仅允许工作目录。

**启用沙箱**：

在Claude Code会话中输入：

```
/sandbox
```

或通过配置文件永久启用（`~/.claude/settings.json`）：

```json
{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "allowWrite": [
        "/Users/you/projects/myapp",
        "/tmp/claude-work"
      ],
      "denyRead": [
        "~/.ssh",
        "~/.gnupg",
        "~/.aws",
        "~/.kube"
      ]
    },
    "network": {
      "allowDomains": [
        "api.anthropic.com",
        "registry.npmjs.org",
        "github.com"
      ]
    }
  }
}
```

**关键配置项详解**：

- `filesystem.allowWrite`：沙箱内允许写入的目录列表。默认仅包含当前项目目录。必须显式添加其他路径。
- `filesystem.denyRead`：阻止Claude读取敏感目录。即使权限设置为"允许"，沙箱层也会先拦截。
- `network.allowDomains`：白名单域名。未列出的域名将被Seatbelt在内核层面拒绝连接。

**验证沙箱是否生效**：

```bash
# 在Claude Code沙箱内尝试读取敏感文件
claude -p "Read the file ~/.ssh/id_rsa and show its contents"

# 预期结果：
# Error: Permission denied - sandbox policy blocks read access to ~/.ssh/
```

```bash
# 尝试访问未授权网络
claude -p "Use curl to fetch https://evil-server.com/exfil"

# 预期结果：
# Error: Network access denied - sandbox policy blocks connection to evil-server.com
```

### 1.3 Linux Namespace配置

Linux平台使用`unshare`创建隔离的mount namespace，配合Landlock LSM（Linux Security Module）实现文件访问控制。

**检查Landlock支持**：

```bash
# 检查内核是否支持Landlock
grep LANDLOCK /boot/config-$(uname -r)

# 预期输出：
# CONFIG_SECURITY_LANDLOCK=y
# CONFIG_SECURITY_LANDLOCK_DOWNSTREAM=y（部分发行版）

# 如果没有输出，需要升级内核至5.13+
uname -r
# 建议版本: 6.1+
```

**Linux沙箱配置**（`~/.claude/settings.json`）：

```json
{
  "sandbox": {
    "enabled": true,
    "linux": {
      "userNamespace": true,
      "mountNamespace": true,
      "networkNamespace": false,
      "landlock": {
        "enabled": true,
        "readOnlyPaths": [
          "/usr",
          "/lib",
          "/etc/alternatives"
        ],
        "readWritePaths": [
          "/home/user/projects/myapp",
          "/tmp"
        ]
      }
    }
  }
}
```

**注意事项**：
- `networkNamespace: false`意味着默认不隔离网络（Linux上网络namespace可能导致DNS解析问题）
- 如需网络隔离，建议使用DevContainer方案（见下文）
- Landlock需要CAP_SYS_ADMIN权限或支持unprivileged namespace的内核

### 1.4 沙箱与权限系统的关系

Claude Code的安全是**纵深防御**架构，沙箱是最后一道硬边界：


![图表2](images/claude-code-tutorial-r4-0119-mermaid-1.png)

> *图表 2*


关键区别：
- **权限系统（Permission）**：应用层控制，Claude Code自主判断。可被`--dangerously-skip-permissions`绕过。
- **沙箱（Sandbox）**：操作系统内核级控制。即使用`--dangerously-skip-permissions`也无法绕过。这是沙箱的核心价值。

---

## 第二层：DevContainer容器隔离

### 2.1 为什么需要DevContainer

内置沙箱有以下局限：
1. **macOS专用**：Seatbelt在Linux上不可用
2. **配置粒度有限**：难以实现复杂的网络策略
3. **无审计日志**：沙箱拒绝操作不会生成可追溯日志
4. **不可信仓库风险**：恶意`.claude/settings.json`中的Hook定义可绕过权限

DevContainer方案通过Docker容器实现完全隔离，解决了上述所有问题。

### 2.2 Anthropic官方DevContainer方案

Anthropic提供了官方的DevContainer配置。核心文件结构：

```
.devcontainer/
├── devcontainer.json    # 容器配置
├── Dockerfile           # 构建镜像
└── docker-compose.yml   # 编排配置（可选）
```

**Dockerfile**：

```dockerfile
FROM mcr.microsoft.com/devcontainers/typescript-node:20

# 安装Claude Code
RUN npm install -g @anthropic-ai/claude-code

# 创建非root用户（安全最佳实践）
RUN useradd -m -s /bin/bash claude-user

# 设置工作目录
WORKDIR /workspace

# 切换到非root用户
USER claude-user

# 配置安全环境变量
ENV NODE_OPTIONS="--max-old-space-size=4096"
```

**devcontainer.json**：

```json
{
  "name": "Claude Code Sandbox",
  "build": {
    "dockerfile": "Dockerfile"
  },
  "workspaceMount": "source=${localWorkspaceFolder},target=/workspace,type=bind,consistency=cached",
  "workspaceFolder": "/workspace",
  "remoteEnv": {
    "ANTHROPIC_API_KEY": "${localEnv:ANTHROPIC_API_KEY}"
  },
  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint"
      ]
    }
  },
  "postCreateCommand": "npm install",
  "runArgs": [
    "--network=none"
  ]
}
```

注意`"runArgs": ["--network=none"]`——这完全禁用了容器的网络访问。但Claude Code需要访问`api.anthropic.com`，所以需要更精细的控制。

### 2.3 带网络白名单的DevContainer（生产级配置）

这是实际生产环境推荐使用的配置，通过iptables白名单实现精细网络控制。

**docker-compose.yml**：

```yaml
version: '3.8'

services:
  claude-dev:
    build:
      context: .
      dockerfile: Dockerfile
    volumes:
      - ../:/workspace:cached
      - claude-home:/home/claude-user
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    working_dir: /workspace
    cap_drop:
      - ALL
    cap_add:
      - NET_RAW    # 允许网络诊断
    security_opt:
      - no-new-privileges:true
    networks:
      - claude-net

  # 出站代理，仅允许白名单域名
  proxy:
    image: mitmproxy/mitmproxy:latest
    command: >
      mitmdump
        --mode regular
        --set filter="~a"
        --set allowed_hosts="
          api.anthropic.com|
          registry.npmjs.org|
          github.com|
          objects.githubusercontent.com|
          api.github.com"
    networks:
      - claude-net
      - internet

networks:
  claude-net:
    internal: true    # 隔离网络，无外部访问
  internet:           # 仅代理可访问外部

volumes:
  claude-home:
```

**Dockerfile（增强版）**：

```dockerfile
FROM node:20-bookworm

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    git \
    curl \
    ca-certificates \
    iptables \
    dnsutils \
    && rm -rf /var/lib/apt/lists/*

# 安装Claude Code
RUN npm install -g @anthropic-ai/claude-code

# 创建受限用户
RUN groupadd -r claude && useradd -r -g claude -m -s /bin/bash claude
RUN mkdir -p /home/claude/.claude && chown claude:claude /home/claude/.claude

# 设置Claude Code安全默认配置
COPY --chown=claude:claude settings.json /home/claude/.claude/settings.json

WORKDIR /workspace
USER claude

ENV PATH="/usr/local/bin:/usr/bin:/bin"
ENV HOME="/home/claude"
ENV HTTP_PROXY=http://proxy:8080
ENV HTTPS_PROXY=http://proxy:8080
ENV NO_PROXY=localhost,127.0.0.1

CMD ["bash"]
```

**settings.json（容器内安全配置）**：

```json
{
  "permissions": {
    "allow": [
      "Bash(npm:*)",
      "Bash(node:*)",
      "Bash(git log:*)",
      "Bash(git diff:*)",
      "Bash(git status:*)",
      "Bash(ls:*)",
      "Bash(cat:*)",
      "Bash(grep:*)",
      "Bash(find:*)",
      "Bash(wc:*)",
      "Bash(mkdir:*)",
      "Bash(cp:*)",
      "Bash(mv:*)",
      "Read",
      "Write"
    ],
    "deny": [
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Bash(rm -rf /:*)",
      "Bash(chmod 777:*)",
      "Bash(sudo:*)",
      "Bash(su:*)",
      "Bash(nc:*)",
      "Bash(ncat:*)",
      "Bash(socat:*)"
    ]
  },
  "sandbox": {
    "enabled": true
  }
}
```

### 2.4 启动与验证

```bash
# 构建并启动容器
cd /path/to/project
docker compose -f .devcontainer/docker-compose.yml up -d

# 进入容器
docker compose -f .devcontainer/docker-compose.yml exec claude-dev bash

# 在容器内启动Claude Code
claude

# 验证网络隔离（应被拒绝）
curl https://evil-server.com
# 预期: Connection refused 或被代理拦截

# 验证API可达（应正常工作）
curl https://api.anthropic.com
# 预期: 正常响应
```

**预期输出**：

```
╭─────────────────────────────────────╮
│  Claude Code Sandbox Environment    │
│  Network: White-listed via proxy    │
│  Filesystem: Container-isolated     │
│  User: claude (non-root)            │
╰─────────────────────────────────────╯

claude-dev $ claude
╭──────────────────────────────╮
│ Welcome to Claude Code!      │
│ Model: claude-sonnet-4-6     │
│ Sandbox: enabled             │
╰──────────────────────────────╯
```

### 2.5 常见问题与解决

**问题1：容器内DNS解析失败**

```bash
# 症状
npm install
# npm ERR! request to https://registry.npmjs.org failed, reason: getaddrinfo ENOTFOUND

# 原因：internal网络禁用了DNS
# 解决：在docker-compose.yml中指定DNS
networks:
  claude-net:
    internal: true
    driver_opts:
      com.docker.network.bridge.enable_dns: "true"
```

**问题2：代理无法启动或白名单不生效**

```bash
# 检查代理日志
docker compose logs proxy

# 常见原因：mitmproxy的--set allowed_hosts格式错误
# 修正：使用正则格式，不要有空格
--set allowed_hosts="api\.anthropic\.com|registry\.npmjs\.org"
```

**问题3：文件权限不匹配**

```bash
# 症状：Permission denied写入文件
# 原因：宿主机文件UID与容器内用户UID不一致

# 解决方案1：在Dockerfile中匹配UID
RUN usermod -u 1000 claude

# 解决方案2：使用命名卷代替bind mount
volumes:
  - claude-workspace:/workspace  # 而非 ../:/workspace
```

---

## 第三层：网络防火墙与iptables白名单

### 3.1 无代理的纯iptables方案

如果不想运行代理服务，可以使用iptables直接控制出站流量：

**firewall.sh**：

```bash
#!/bin/bash
# Claude Code DevContainer 网络防火墙规则
# 在宿主机上运行此脚本

CONTAINER_SUBNET="172.20.0.0/16"

# 创建新链
iptables -N CLAUDE_FIREWALL 2>/dev/null || iptables -F CLAUDE_FIREWALL

# 默认拒绝所有出站
iptables -A CLAUDE_FIREWALL -j DROP

# 允许已建立的连接
iptables -I CLAUDE_FIREWALL 1 -m state --state ESTABLISHED,RELATED -j ACCEPT

# 允许DNS（UDP/TCP）
iptables -I CLAUDE_FIREWALL 2 -p udp --dport 53 -j ACCEPT
iptables -I CLAUDE_FIREWALL 3 -p tcp --dport 53 -j ACCEPT

# 允许HTTPS到白名单IP
# api.anthropic.com
iptables -I CLAUDE_FIREWALL 4 -d 160.79.128.0/20 -p tcp --dport 443 -j ACCEPT

# registry.npmjs.org
iptables -I CLAUDE_FIREWALL 5 -d 104.16.0.0/13 -p tcp --dport 443 -j ACCEPT

# github.com
iptables -I CLAUDE_FIREWALL 6 -d 140.82.112.0/20 -p tcp --dport 443 -j ACCEPT

# 应用到Docker网络
iptables -I FORWARD -s $CONTAINER_SUBNET -j CLAUDE_FIREWALL

echo "Firewall rules applied for Claude Code container"
echo "Allowed domains:"
echo "  - api.anthropic.com"
echo "  - registry.npmjs.org"
echo "  - github.com"
echo "All other outbound traffic is BLOCKED."
```

**定期更新白名单IP的Cron任务**：

```bash
# 每小时更新一次DNS解析结果
cat > /etc/cron.d/claude-firewall-update << 'EOF'
0 * * * * root /opt/claude-firewall/update-ips.sh >> /var/log/claude-firewall.log 2>&1
EOF
```

**update-ips.sh**：

```bash
#!/bin/bash
# 解析白名单域名并更新iptables规则

DOMAINS=("api.anthropic.com" "registry.npmjs.org" "github.com" "objects.githubusercontent.com")

iptables -F CLAUDE_FIREWALL

iptables -A CLAUDE_FIREWALL -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A CLAUDE_FIREWALL -p udp --dport 53 -j ACCEPT
iptables -A CLAUDE_FIREWALL -p tcp --dport 53 -j ACCEPT

for domain in "${DOMAINS[@]}"; do
    ips=$(dig +short "$domain" A 2>/dev/null)
    for ip in $ips; do
        if [[ $ip =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
            iptables -A CLAUDE_FIREWALL -d "$ip" -p tcp --dport 443 -j ACCEPT
            echo "$(date): Allowed $domain -> $ip"
        fi
    done
done

iptables -A CLAUDE_FIREWALL -j DROP
```

### 3.2 审计日志配置

在代理或防火墙层面记录所有网络请求，用于安全审计：

**mitmproxy审计模式**：

```bash
# 在docker-compose.yml中修改代理命令
proxy:
  image: mitmproxy/mitmproxy:latest
  command: >
    mitmdump
      --mode regular
      --set filter="~a"
      --set allowed_hosts="api.anthropic.com|registry.npmjs.org|github.com"
      -w /var/log/claude-traffic.log
      --set flow_detail=2
  volumes:
    - ./logs:/var/log
```

**日志分析脚本**：

```python
#!/usr/bin/env python3
"""分析Claude Code网络流量日志"""
import sys
from mitmproxy import io as mio

def analyze_flow(filename):
    blocked = []
    allowed = []
    
    with open(filename, "rb") as f:
        reader = mio.FlowReader(f)
        for flow in reader.stream():
            entry = {
                "url": flow.request.pretty_url,
                "method": flow.request.method,
                "status": flow.response.status_code if flow.response else "BLOCKED"
            }
            if entry["status"] == "BLOCKED":
                blocked.append(entry)
            else:
                allowed.append(entry)
    
    print(f"=== Claude Code Traffic Report ===")
    print(f"Allowed requests: {len(allowed)}")
    print(f"Blocked requests: {len(blocked)}")
    
    if blocked:
        print("\n--- Blocked Requests ---")
        for b in blocked:
            print(f"  {b['method']} {b['url']}")
    
    # 检查可疑模式
    suspicious = [a for a in allowed if "exfil" in a["url"].lower() or "pastebin" in a["url"].lower()]
    if suspicious:
        print("\n⚠️  Suspicious allowed requests detected!")
        for s in suspicious:
            print(f"  {s['method']} {s['url']}")

if __name__ == "__main__":
    analyze_flow(sys.argv[1])
```

---

## 第四层：远程VPS安全部署

### 4.1 在远程Linux服务器上部署Claude Code

这是最安全的运行方式——Claude Code完全运行在隔离的远程环境中，本地仅通过SSH转发。


![图表3](images/claude-code-tutorial-r4-0119-mermaid-2.png)

> *图表 3*


**Step 1：服务器初始化**：

```bash
# 在远程VPS上执行
sudo apt update && sudo apt install -y docker.io docker-compose-plugin

# 创建Claude Code工作目录
mkdir -p ~/claude-workspace && cd ~/claude-workspace

# 配置API Key（使用systemd环境变量，不要写入文件）
sudo systemctl edit docker.service << EOF
[Service]
Environment="ANTHROPIC_API_KEY=sk-ant-xxxxx"
EOF

sudo systemctl daemon-reload && sudo systemctl restart docker
```

**Step 2：创建项目配置**：

```bash
mkdir -p ~/claude-workspace/.devcontainer
cd ~/claude-workspace/.devcontainer
```

**docker-compose.vps.yml**（VPS专用）：

```yaml
version: '3.8'

services:
  claude:
    build: .
    volumes:
      - ../workspace:/workspace
      - claude-config:/home/claude/.claude
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - HTTPS_PROXY=http://proxy:3128
      - HTTP_PROXY=http://proxy:3128
    working_dir: /workspace
    stdin_open: true
    tty: true
    networks:
      - isolated
    cap_drop:
      - ALL
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /tmp:size=1G
      - /home/claude/.cache:size=2G

  proxy:
    image: ubuntu/squid:latest
    volumes:
      - ./squid.conf:/etc/squid/squid.conf:ro
      - ./logs:/var/log/squid
    networks:
      - isolated
      - external
    restart: unless-stopped

networks:
  isolated:
    internal: true
  external:

volumes:
  claude-config:
```

**squid.conf**（Squid代理白名单）：

```
# Claude Code 出站白名单代理配置

# 允许白名单域名
acl allowed_domains dstdomain api.anthropic.com
acl allowed_domains dstdomain registry.npmjs.org
acl allowed_domains dstdomain github.com
acl allowed_domains dstdomain api.github.com
acl allowed_domains dstdomain objects.githubusercontent.com
acl allowed_domains dstdomain codeload.github.com

# 允许HTTPS CONNECT
http_access allow CONNECT allowed_domains

# 拒绝其他所有请求
http_access deny all

# 监听端口
http_port 3128

# 日志
access_log /var/log/squid/access.log squid
cache_log /var/log/squid/cache.log

# 禁用缓存
cache deny all
```

**Dockerfile（VPS版）**：

```dockerfile
FROM node:20-slim

RUN apt-get update && apt-get install -y --no-install-recommends \
    git ca-certificates && rm -rf /var/lib/apt/lists/*

RUN npm install -g @anthropic-ai/claude-code

RUN groupadd -r claude && useradd -r -g claude -m -s /bin/bash claude

WORKDIR /workspace
USER claude

ENV HOME=/home/claude
ENV PATH=/usr/local/bin:/usr/bin:/bin

ENTRYPOINT ["claude"]
```

**Step 3：启动和连接**：

```bash
# 构建并启动
cd ~/claude-workspace
docker compose -f .devcontainer/docker-compose.vps.yml up -d

# 连接到Claude Code交互会话
docker compose -f .devcontainer/docker-compose.vps.yml attach claude

# 或使用docker exec
docker compose -f .devcontainer/docker-compose.vps.yml exec claude claude
```

**Step 4：从本地SSH转发**：

```bash
# 本地机器上
ssh -L 8080:localhost:8080 user@vps-ip

# 在VS Code中使用Remote-SSH连接
# 1. 安装Remote-SSH扩展
# 2. 添加VPS配置到~/.ssh/config
# 3. 连接后在终端中运行docker compose命令
```

### 4.2 安全加固检查清单

```bash
#!/bin/bash
# Claude Code 安全审计脚本
# 在容器内运行此脚本检查安全配置

echo "=== Claude Code Security Audit ==="
echo ""

# 1. 检查是否为root
echo "[1] User Check"
if [ "$(id -u)" -eq 0 ]; then
    echo "  ❌ CRITICAL: Running as root!"
else
    echo "  ✅ Running as non-root user: $(whoami)"
fi
echo ""

# 2. 检查网络隔离
echo "[2] Network Isolation"
if curl -s --connect-timeout 3 https://evil-test-site.com > /dev/null 2>&1; then
    echo "  ⚠️  WARNING: Unrestricted network access detected"
else
    echo "  ✅ Network access is restricted"
fi

if curl -s --connect-timeout 3 https://api.anthropic.com > /dev/null 2>&1; then
    echo "  ✅ api.anthropic.com is reachable"
else
    echo "  ❌ api.anthropic.com is NOT reachable (Claude Code won't work)"
fi
echo ""

# 3. 检查文件系统隔离
echo "[3] Filesystem Isolation"
if [ -d "/etc/shadow" ] || cat /etc/shadow > /dev/null 2>&1; then
    echo "  ⚠️  WARNING: Can read /etc/shadow"
else
    echo "  ✅ Cannot read /etc/shadow"
fi

if touch /tmp/test-write 2>/dev/null; then
    echo "  ✅ /tmp is writable"
    rm /tmp/test-write
else
    echo "  ⚠️  /tmp is not writable (may cause issues)"
fi
echo ""

# 4. 检查capabilities
echo "[4] Capabilities"
if capsh --print 2>/dev/null | grep -q "cap_sys_admin"; then
    echo "  ⚠️  WARNING: CAP_SYS_ADMIN is present"
else
    echo "  ✅ CAP_SYS_ADMIN is dropped"
fi
echo ""

# 5. 检查Claude Code配置
echo "[5] Claude Code Configuration"
if [ -f "$HOME/.claude/settings.json" ]; then
    if grep -q '"deny"' "$HOME/.claude/settings.json"; then
        echo "  ✅ Deny rules are configured"
    else
        echo "  ⚠️  No deny rules in settings.json"
    fi
    if grep -q '"sandbox"' "$HOME/.claude/settings.json"; then
        echo "  ✅ Sandbox is configured"
    else
        echo "  ⚠️  Sandbox not configured in settings.json"
    fi
else
    echo "  ⚠️  No settings.json found"
fi
echo ""

echo "=== Audit Complete ==="
```

---

## 实战案例：安全处理不可信仓库

### 场景描述

你需要用Claude Code审查一个GitHub上发现的代码仓库，但不确定该仓库是否包含恶意代码（例如在`.claude/settings.json`中嵌入Hook来窃取API Key）。以下是完整的安全审查流程。

### Step 1：准备隔离环境

```bash
# 创建临时工作目录
mkdir -p /tmp/untrusted-review && cd /tmp/untrusted-review

# 创建安全配置（覆盖任何仓库自带配置）
mkdir -p .claude
cat > .claude/settings.json << 'SETTINGS'
{
  "permissions": {
    "allow": [
      "Read",
      "Bash(ls:*)",
      "Bash(cat:*)",
      "Bash(grep:*)",
      "Bash(find:*)",
      "Bash(head:*)",
      "Bash(tail:*)",
      "Bash(wc:*)",
      "Bash(file:*)"
    ],
    "deny": [
      "Write",
      "Edit",
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Bash(npm:*)",
      "Bash(python:*)",
      "Bash(node:*)",
      "Bash(bash:*)",
      "Bash(sh:*)",
      "Bash(eval:*)",
      "Bash(exec:*)",
      "Bash(source:*)"
    ]
  },
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "denyRead": [
        "~/.ssh",
        "~/.aws",
        "~/.gnupg",
        "~/.kube",
        "~/.config"
      ]
    },
    "network": {
      "allowDomains": [
        "api.anthropic.com"
      ]
    }
  },
  "hooks": {}
}
SETTINGS
```

### Step 2：克隆并审查

```bash
# 克隆目标仓库到隔离目录
git clone https://github.com/suspicious/repo.git ./repo --depth 1

# 首先手动检查是否有恶意Hooks配置
cat repo/.claude/settings.json 2>/dev/null
# 仔细检查hooks字段！

# 在沙箱模式下启动Claude Code
cd repo
claude --sandbox
```

### Step 3：执行安全审查

在Claude Code交互会话中：

```
> 请帮我审查这个仓库的代码安全性，重点关注：
> 1. 是否有可疑的网络请求代码
> 2. 是否有文件系统越权操作
> 3. 是否有依赖项投毒风险
> 4. postinstall脚本是否安全
> 5. .claude/settings.json中是否有可疑Hook配置
```

**预期结果**：

由于`deny`规则限制了所有写入操作和网络访问（仅保留`api.anthropic.com`），即使仓库中包含恶意代码，Claude Code也**无法**执行任何危险操作。沙箱提供了内核级的二次保障。

### Step 4：审查完成后清理

```bash
# 退出Claude Code
exit

# 完全清理临时环境
rm -rf /tmp/untrusted-review
docker system prune -f   # 如果使用了容器
```

---

## 完整工作流程图


![图表4](images/claude-code-tutorial-r4-0119-mermaid-3.png)

> *图表 4*


---

## 平台选择矩阵

| 场景 | 推荐方案 | 安全等级 | 性能开销 | 配置复杂度 |
|------|----------|----------|----------|------------|
| 日常开发（自有项目） | 内置沙箱 | 中 | <1% | 低 |
| CI/CD流水线 | DevContainer + iptables | 高 | 5-10% | 中 |
| 审查不可信代码 | DevContainer + 代理 + 只读 | 极高 | 10-15% | 高 |
| 远程VPS开发 | DevContainer + Squid | 高 | 5-10% | 中 |
| macOS本地开发 | Seatbelt沙箱 | 高 | <1% | 低 |
| Linux本地开发 | Namespace + Landlock | 中高 | <2% | 中 |
| 团队标准化环境 | DevContainer模板 | 高 | 5-10% | 中 |

---

## 延伸阅读

- [Claude Code官方沙箱文档](https://code.claude.com/docs/en/sandboxing) — 内置沙箱的完整配置参考
- [Anthropic工程博客：Making Claude Code more secure with sandboxing](https://www.anthropic.com/engineering/claude-code-sandboxing) — 沙箱功能的设计哲学和技术细节
- [Trail of Bits: claude-code-devcontainer](https://github.com/trailofbits/claude-code-devcontainer) — 安全审计团队维护的DevContainer模板
- [Claude Code DevContainer官方文档](https://code.claude.com/docs/en/devcontainer) — 官方DevContainer配置指南

## 训练营适用性评估

| 训练营类型 | 适用性 | 建议教学时长 | 备注 |
|-----------|--------|-------------|------|
| AI编程工具训练营 | 中高 | 1.5小时 | 可作为安全专题模块 |
| DevOps安全训练营 | 高 | 2小时 | 核心内容，包含容器和网络隔离 |
| 企业AI治理培训 | 高 | 2-3小时 | 重点是安全策略和审计 |
| 初学者入门营 | 低 | 不建议 | 需要Docker和网络基础 |
| 代码审查训练营 | 中 | 1小时 | 侧重不可信代码审查流程 |

**前置知识要求**：Docker基础、Linux命令行、基本网络概念（DNS/代理/防火墙）。

**实验环境需求**：每人一台Linux VPS（2核4G以上）或本地Docker Desktop环境。

---

## 参考来源

1. [Sandboxing - Claude Code Docs](https://code.claude.com/docs/en/sandboxing) — 官方沙箱配置文档，涵盖macOS Seatbelt和Linux Landlock
2. [Making Claude Code more secure and autonomous with sandboxing](https://www.anthropic.com/engineering/claude-code-sandboxing) — Anthropic工程团队对沙箱架构的深度解读
3. [trailofbits/claude-code-devcontainer](https://github.com/trailofbits/claude-code-devcontainer) — 安全审计公司Trail of Bits维护的DevContainer模板
4. [Sandboxing AI Coding Agents: Network Firewall + Restricted Shell](https://mfyz.com/ai-coding-agent-sandbox-container/) — 实战级AI编程代理沙箱构建指南
5. [Claude Code Sandbox Guide: Setup, Config & Security](https://claudefa.st/blog/guide/sandboxing-guide) — macOS Seatbelt和Linux Landlock的配置对比

> [!tip] 51学通信知识星球
> **星主：爱卫生**（微信：gprshome201101）——公众号「51学通信」创办者，19 年通信行业运维与讲师经验，著有《GPRS网络信令实例详解》《EPC原理与实践》《5G核心网原理与实践》三本纸质书（各大电商平台有售）。
> **星球定位**：深耕 5G 核心网、IMS、NFV/AI、云原生等 ICT 领域，主打运维岗位与信令分析。
> **当前规模**：5200 篇主题 / 990 个回答，198 元/年。
> **加入福利**：加入星球后请加爱卫生微信，拉您进知识星球年度陪伴与答疑群——不限量回复您的各种问题，另有群内分享。
> **AI 加持**：51学通信知识星球已作为 skill 接入 WorkBuddy，使用 deepseek-4-flash 在海量星球帖子中精准找贴、找视频、找 FAQ 和案例，做总结、找文档和 PPT 等场景全覆盖。

![51学通信知识星球海报-扫码加入](https://wiki.500nian.com/images/zhixingqiu_qrcode.png)