bash permissions

Bash 权限检查是 Claude Code 安全系统的核心，包含 2600+ 行的详细规则。

设计目标

Shell 命令执行是最危险的操作之一，需要细粒度的控制：

1. 防止破坏性操作 - rm -rf /, chmod 777

2. 防止权限提升 - sudo, su

3. 防止数据泄露 - curl 敏感文件到外部

4. 防止恶意代码 - 下载并执行脚本

命令分类

分类系统

type CommandLevel = 
  | 'safe'       // 完全安全，自动批准
  | 'read'       // 只读操作
  | 'write'      // 写操作
  | 'network'    // 网络访问
  | 'dangerous'  // 危险操作
  | 'forbidden'; // 禁止执行

interface CommandClassification {
  level: CommandLevel;
  reason: string;
  confidence: number;
}

分类规则

// src/tools/BashTool/bashPermissions.ts

function classifyCommand(command: string): CommandClassification {
  // 1. 检查禁止的命令
  if (isForbidden(command)) {
    return { level: 'forbidden', reason: 'Blacklisted command' };
  }
  
  // 2. 检查危险模式
  if (isDangerous(command)) {
    return { level: 'dangerous', reason: 'Potentially harmful' };
  }
  
  // 3. 检查网络操作
  if (isNetworkCommand(command)) {
    return { level: 'network', reason: 'Network access' };
  }
  
  // 4. 检查写操作
  if (isWriteCommand(command)) {
    return { level: 'write', reason: 'Modifies files' };
  }
  
  // 5. 检查只读操作
  if (isReadCommand(command)) {
    return { level: 'read', reason: 'Read-only' };
  }
  
  // 6. 默认为安全
  return { level: 'safe', reason: 'Known safe command' };
}

禁止的命令

黑名单

const FORBIDDEN_PATTERNS = [
  // 删除根目录
  /rm\s+-rf\s+\//,
  /rm\s+-rf\s+~\//,
  
  // 权限提升
  /sudo\s+/,
  /su\s+/,
  
  // 修改权限
  /chmod\s+777/,
  /chown\s+/,
  
  // 下载并执行
  /curl\s+.*\|\s*bash/,
  /wget\s+.*\|\s*sh/,
  
  // 直接写入设备
  />\s*\/dev\/sd[a-z]/,
  
  // 修改系统文件
  />\s*\/etc\//,
  />\s*\/sys\//,
];

function isForbidden(command: string): boolean {
  return FORBIDDEN_PATTERNS.some(pattern => pattern.test(command));
}

危险命令

检测规则

const DANGEROUS_PATTERNS = [
  // 递归删除
  /rm\s+-r/,
  
  // 强制操作
  /rm\s+-f/,
  
  // 修改 PATH
  /export\s+PATH=/,
  
  // 后台执行
  /&\s*$/,
  
  // 重定向到重要文件
  />\s*~\/\.(bashrc|zshrc|profile)/,
];

function isDangerous(command: string): boolean {
  return DANGEROUS_PATTERNS.some(pattern => pattern.test(command));
}

上下文检查

某些命令在特定上下文下才危险：

function isDangerousInContext(
  command: string,
  context: ToolContext
): boolean {
  // rm 在根目录下很危险
  if (command.startsWith('rm') && context.cwd === '/') {
    return true;
  }
  
  // chmod 在系统目录下很危险
  if (command.startsWith('chmod') && context.cwd.startsWith('/usr')) {
    return true;
  }
  
  return false;
}

安全命令

白名单

const SAFE_COMMANDS = new Set([
  // 文件查看
  'ls', 'cat', 'head', 'tail', 'less', 'more',
  
  // 搜索
  'grep', 'find', 'locate', 'which',
  
  // Git 只读
  'git status', 'git log', 'git diff', 'git show',
  
  // 包管理器只读
  'npm list', 'npm outdated', 'yarn list',
  
  // 系统信息
  'pwd', 'whoami', 'date', 'uname',
]);

function isSafe(command: string): boolean {
  const base = command.trim().split(' ')[0];
  return SAFE_COMMANDS.has(base) || SAFE_COMMANDS.has(command);
}

特殊处理

Git 命令

function classifyGitCommand(command: string): CommandLevel {
  // 只读操作
  if (/^git\s+(status|log|diff|show|branch)/.test(command)) {
    return 'read';
  }
  
  // 写操作
  if (/^git\s+(add|commit|push)/.test(command)) {
    return 'write';
  }
  
  // 危险操作
  if (/^git\s+(reset\s+--hard|clean\s+-fd)/.test(command)) {
    return 'dangerous';
  }
  
  return 'write';
}

npm/yarn 命令

function classifyPackageCommand(command: string): CommandLevel {
  // 只读
  if (/^(npm|yarn)\s+(list|outdated|info)/.test(command)) {
    return 'read';
  }
  
  // 安装依赖
  if (/^(npm|yarn)\s+install/.test(command)) {
    return 'write';
  }
  
  // 运行脚本
  if (/^(npm|yarn)\s+run/.test(command)) {
    // 检查脚本内容
    return classifyScript(extractScriptName(command));
  }
  
  return 'write';
}

权限决策

决策树

async function checkBashPermission(
  command: string,
  context: ToolContext
): Promise<PermissionResult> {
  // 1. 分类命令
  const classification = classifyCommand(command);
  
  // 2. 检查黑名单
  if (classification.level === 'forbidden') {
    return { allowed: false, reason: classification.reason };
  }
  
  // 3. 检查模式
  const mode = context.state.permissions.mode;
  
  if (mode === 'auto') {
    return autoModeDecision(classification, command, context);
  } else if (mode === 'manual') {
    return await askUser(command, classification);
  } else if (mode === 'supervised') {
    return await supervisedDecision(command, classification, context);
  }
}

Auto 模式决策

function autoModeDecision(
  classification: CommandClassification,
  command: string,
  context: ToolContext
): PermissionResult {
  switch (classification.level) {
    case 'safe':
    case 'read':
      return { allowed: true };
      
    case 'write':
      // 使用分类器
      return classifierApprove(command, context);
      
    case 'network':
      // 检查目标主机
      return checkNetworkTarget(command);
      
    case 'dangerous':
      return { allowed: false, reason: 'Dangerous operation' };
      
    default:
      return { allowed: false, reason: 'Unknown command' };
  }
}

下一步

• 了解 沙箱执行 的隔离机制

• 探索 分类器 的智能审批

• 查看 BashTool 的完整实现