Day-134-静态代码分析SAST

# Day 148: 静态代码分析 SAST

> 应用安全系列第 41 天 | 预计阅读时间：50 分钟 | 难度：★★★★☆

---

**PUA v3 · Sprint 启动** 
```
┌─────────┬────────────────────────────────────┐
│ 清单 任务 │ 静态代码分析 SAST - Day 148        │
├─────────┼────────────────────────────────────┤
│  味道 │  阿里味（自动：安全任务）        │
├─────────┼────────────────────────────────────┤
│  压力 │ L0 · 信任期                        │
└─────────┴────────────────────────────────────┘
```
▎ SAST 不是装工具就完事，是建体系。体系不建立，扫描就是形式的。今天深入静态代码分析 SAST。

---

## 清单 目录

1. [SAST 概述](#sast 概述)
2. [SAST 工作原理](#sast 工作原理)
3. [SAST 工具对比](#sast 工具对比)
4. [规则引擎设计](#规则引擎设计)
5. [误报处理](#误报处理)
6. [CI/CD 集成](#cicd 集成)
7. [结果分析与修复](#结果分析与修复)
8. [企业级部署](#企业级部署)
9. [实战配置演练](#实战配置演练)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## SAST 概述

### 什么是 SAST

> ▎ SAST 不是找 bug，是找安全漏洞。漏洞不找出来，上线就是给别人送钱。

**定义与特点**：
```
SAST (Static Application Security Testing) 是在不执行代码的情况下，对源代码进行安全分析的技术。

核心特点：
1. 白盒测试
   - 访问源代码
   - 分析数据流
   - 发现深层问题

2. 早期发现
   - 开发阶段发现
   - 修复成本低
   - 安全左移

3. 全面覆盖
   - 所有代码路径
   - 所有输入点
   - 所有汇聚点
```

**SAST 价值**：
```
SAST 投资回报：

发现阶段      修复成本    相对成本
─────────────────────────────────
开发阶段      $100       1x
测试阶段      $1,000     10x
生产阶段      $10,000    100x

SAST 收益：
- 漏洞发现提前 80%
- 修复成本降低 90%
- 安全审查时间减少 60%
```

### SAST 适用场景

**适用场景**：
```
+ 适合使用 SAST:
- 新代码开发
- 代码重构
- 第三方代码集成
- 合规要求
- 安全基线建立

- 不适合仅用 SAST:
- 运行时问题
- 配置问题
- 业务逻辑漏洞
- 认证绕过 (部分)
- 需要 DAST 补充
```

---

## SAST 工作原理

### 分析流程

> ▎ SAST 不是简单匹配，是深度分析。分析不深度，漏洞就是表面的。

**SAST 分析流程**：
```python
# SAST 引擎工作流程
class SASTEngine:
    """SAST 分析引擎"""
    
    def analyze(self, codebase):
        """执行 SAST 分析"""
        # 1. 代码解析
        ast = self.parse_code(codebase)
        
        # 2. 控制流分析
        cfg = self.build_cfg(ast)
        
        # 3. 数据流分析
        dfg = self.build_dfg(cfg)
        
        # 4. 污点分析
        taint_results = self.taint_analysis(dfg)
        
        # 5. 模式匹配
        pattern_results = self.pattern_matching(ast)
        
        # 6. 语义分析
        semantic_results = self.semantic_analysis(ast, cfg)
        
        # 7. 结果汇总
        issues = self.aggregate_results(
            taint_results,
            pattern_results,
            semantic_results
        )
        
        # 8. 误报过滤
        filtered_issues = self.filter_false_positives(issues)
        
        return filtered_issues
    
    def parse_code(self, codebase):
        """代码解析 - 生成 AST"""
        # 词法分析 → 语法分析 → AST
        ast = {}
        for file in codebase:
            ast[file] = self.generate_ast(file)
        return ast
    
    def build_cfg(self, ast):
        """构建控制流图"""
        cfg = {}
        for file, tree in ast.items():
            cfg[file] = self.generate_cfg(tree)
        return cfg
    
    def build_dfg(self, cfg):
        """构建数据流图"""
        dfg = {}
        for file, graph in cfg.items():
            dfg[file] = self.generate_dfg(graph)
        return dfg
    
    def taint_analysis(self, dfg):
        """污点分析"""
        results = []
        
        # 定义污点源
        sources = self.define_sources()
        
        # 定义污点汇聚
        sinks = self.define_sinks()
        
        # 定义清理函数
        sanitizers = self.define_sanitizers()
        
        # 追踪污点流
        for file, graph in dfg.items():
            paths = self.find_taint_paths(graph, sources, sinks, sanitizers)
            results.extend(paths)
        
        return results
    
    def pattern_matching(self, ast):
        """模式匹配"""
        results = []
        
        # 预定义漏洞模式
        patterns = self.load_vulnerability_patterns()
        
        for file, tree in ast.items():
            for pattern in patterns:
                matches = self.search_pattern(tree, pattern)
                results.extend(matches)
        
        return results
    
    def filter_false_positives(self, issues):
        """误报过滤"""
        filtered = []
        
        for issue in issues:
            # 应用误报过滤规则
            if not self.is_false_positive(issue):
                filtered.append(issue)
        
        return filtered
```

### 分析技术

**核心技术**：
```
1. 词法分析 (Lexical Analysis)
   ├── 源代码 → Token 流
   ├── 识别关键字
   └── 识别标识符

2. 语法分析 (Syntax Analysis)
   ├── Token 流 → AST
   ├── 构建语法树
   └── 验证语法正确性

3. 控制流分析 (Control Flow Analysis)
   ├── 构建 CFG
   ├── 识别执行路径
   └── 识别循环/分支

4. 数据流分析 (Data Flow Analysis)
   ├── 追踪变量定义和使用
   ├── 构建数据流图
   └── 识别数据依赖

5. 污点分析 (Taint Analysis)
   ├── 识别污点源
   ├── 追踪污点传播
   └── 识别污点汇聚
```

---

## SAST 工具对比

### 主流工具

> ▎ 工具不是选最贵，是选最合适。工具不合适，效果就是打折的。

**工具对比表**：
```
┌─────────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
│     工具        │   支持语言   │   检测能力   │   误报率     │   成本       │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   Bandit        │  Python      │  中          │  中          │  免费        │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   Semgrep       │  多语言      │  高          │  低          │  免费/商业   │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   SonarQube     │  多语言      │  高          │  中          │  免费/商业   │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   CodeQL        │  多语言      │  很高        │  低          │  免费        │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   Fortify       │  多语言      │  很高        │  中          │  商业        │
├─────────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
│   Checkmarx     │  多语言      │  很高        │  中          │  商业        │
└─────────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
```

### Bandit 使用

```python
# Bandit 配置和使用
"""
# 安装
pip install bandit

# 基本使用
bandit -r ./src

# JSON 输出
bandit -r ./src -f json -o report.json

# 排除目录
bandit -r ./src --exclude-dir tests,venv

# 跳过特定检查
bandit -r ./src --skip B101,B306

# 配置文件 (.bandit)
[bandit]
targets = src
exclude_dirs = tests,venv
skips = B101,B306
aggregate = vuln

# CI/CD 集成
# .gitlab-ci.yml
bandit_scan:
  stage: test
  script:
    - pip install bandit
    - bandit -r ./src -f json -o bandit-report.json
    - bandit -r ./src --exit-zero  # 不阻断 pipeline
  artifacts:
    reports:
      security: bandit-report.json
"""

# Bandit 规则示例
"""
# B101: assert 使用
# 问题：assert 在优化模式下被移除
assert user.is_admin  # 不安全

# B306: mktemp 使用
# 问题：mktemp 有不安全竞态条件
temp = tempfile.mktemp()  # 不安全
temp = tempfile.mkstemp()  # 安全

# B608: SQL 注入
# 问题：字符串拼接 SQL
cursor.execute("SELECT * FROM users WHERE id = %s" % user_id)  # 不安全
cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))  # 安全

# B609: shell=True
# 问题：命令注入风险
subprocess.run(cmd, shell=True)  # 不安全
subprocess.run([cmd, arg1, arg2])  # 安全
"""
```

### Semgrep 使用

```python
# Semgrep 规则编写
"""
# 规则文件：sql-injection.yml
rules:
  - id: python-sql-injection
    patterns:
      - pattern: |
          $CURSOR.execute("...$VAR...")
      - metavariable-pattern:
          metavariable: $VAR
          pattern: |
            % ...
    message: "Possible SQL injection via string formatting"
    languages: [python]
    severity: ERROR
    metadata:
      cwe: "CWE-89: SQL Injection"
      owasp: "A03:2021-Injection"

# 使用 f-string 的 SQL 注入
  - id: python-sql-injection-fstring
    patterns:
      - pattern: |
          $CURSOR.execute(f"...{$VAR}...")
    message: "SQL injection via f-string"
    languages: [python]
    severity: ERROR

# 使用 format 的 SQL 注入
  - id: python-sql-injection-format
    patterns:
      - pattern: |
          $CURSOR.execute("...{}".format($VAR))
    message: "SQL injection via format()"
    languages: [python]
    severity: ERROR

# 命令注入
  - id: python-command-injection
    patterns:
      - pattern: |
          subprocess.$FUNC($CMD, shell=True)
      - metavariable: $CMD
        pattern-not: |
          "..."
    message: "Command injection risk with shell=True"
    languages: [python]
    severity: ERROR

# XSS
  - id: python-xss
    patterns:
      - pattern: |
          return $FUNC(request.$ATTR[$KEY])
      - metavariable: $FUNC
        pattern-not: |
          escape
        pattern-not: |
          Markup.escape
    message: "Possible XSS - user input returned without escaping"
    languages: [python]
    severity: WARNING
"""

# Semgrep 使用命令
"""
# 运行官方规则
semgrep --config auto ./src

# 运行自定义规则
semgrep --config ./rules/ ./src

# 运行特定规则
semgrep --config ./rules/sql-injection.yml ./src

# JSON 输出
semgrep --config auto --json ./src -o semgrep-report.json

# 忽略特定规则
semgrep --config auto --exclude-rule python-sql-injection ./src

# 严格模式 (有高危问题就失败)
semgrep --config auto --error ./src
"""
```

### SonarQube 使用

```yaml
# SonarQube 配置
"""
# docker-compose.yml
version: '3'
services:
  sonarqube:
    image: sonarqube:lts
    ports:
      - "9000:9000"
    environment:
      - SONAR_ES_BOOTSTRAP_CHECKS_DISABLE=true
    volumes:
      - sonarqube_data:/opt/sonarqube/data
      - sonarqube_extensions:/opt/sonarqube/extensions
      - sonarqube_logs:/opt/sonarqube/logs

volumes:
  sonarqube_data:
  sonarqube_extensions:
  sonarqube_logs:

# sonar-project.properties
sonar.projectKey=myproject
sonar.projectName=My Project
sonar.projectVersion=1.0

sonar.sources=src
sonar.tests=tests
sonar.exclusions=**/tests/**,**/venv/**

sonar.python.coverage.reportPaths=coverage.xml
sonar.python.xunit.reportPath=test-results.xml

# 质量门配置
sonar.qualitygate.wait=true
sonar.qualitygate.timeout=300

# GitHub Actions 集成
# .github/workflows/sonarqube.yml
name: SonarQube Scan

on:
  pull_request:
    branches: [main]

jobs:
  sonarqube:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
      with:
        fetch-depth: 0
    
    - name: SonarQube Scan
      uses: sonarsource/sonarqube-scan-action@master
      env:
        SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}
"""
```

---

## 规则引擎设计

### 自定义规则

> ▎ 规则不是越多越好，是越准越好。规则不准，误报就是灾难的。

**规则设计原则**：
```python
# 规则设计原则
class RuleDesignPrinciples:
    """
    规则设计原则:
    
    1. 精确性
       - 匹配具体模式
       - 避免过度匹配
       - 减少误报
    
    2. 完整性
       - 覆盖常见漏洞
       - 考虑变体形式
       - 持续更新
    
    3. 可维护性
       - 规则清晰
       - 文档完善
       - 易于测试
    
    4. 性能
       - 避免复杂正则
       - 增量分析
       - 缓存结果
    """
    
    # 规则模板
    rule_template = {
        'id': 'unique-rule-id',
        'name': 'Rule Name',
        'description': 'Clear description of what the rule detects',
        'severity': 'ERROR|WARNING|INFO',
        'languages': ['python'],
        'patterns': [],
        'message': 'Clear message explaining the issue',
        'fix': 'Suggested fix',
        'references': ['CWE-XXX', 'OWASP']
    }

# Semgrep 规则示例
sql_injection_rules = """
rules:
  # 规则 1: 基本 SQL 注入
  - id: sql-injection-basic
    patterns:
      - pattern: |
          $CURSOR.execute($SQL)
      - metavariable-pattern:
          metavariable: $SQL
          patterns:
            - pattern-not: '"..."'
            - pattern-not: "'...'"
            - pattern: |
                % ...
    message: "SQL injection risk: user input in SQL query"
    languages: [python]
    severity: ERROR
    
  # 规则 2: f-string SQL 注入
  - id: sql-injection-fstring
    patterns:
      - pattern: |
          $CURSOR.execute(f$SQL)
    message: "SQL injection risk: f-string in SQL query"
    languages: [python]
    severity: ERROR
    
  # 规则 3: format() SQL 注入
  - id: sql-injection-format
    patterns:
      - pattern: |
          $CURSOR.execute($SQL.format(...))
    message: "SQL injection risk: format() in SQL query"
    languages: [python]
    severity: ERROR
    
  # 规则 4: 字符串拼接 SQL 注入
  - id: sql-injection-concat
    patterns:
      - pattern: |
          $CURSOR.execute($A + $B)
    message: "SQL injection risk: string concatenation in SQL"
    languages: [python]
    severity: ERROR
"""

# 规则测试
"""
# 测试文件：test-sql-injection.py

# 应该匹配 (有问题)
cursor.execute("SELECT * FROM users WHERE id = %s" % user_id)  # Match
cursor.execute(f"SELECT * FROM users WHERE id = {user_id}")  # Match
cursor.execute("SELECT * FROM users WHERE id = {}".format(user_id))  # Match
cursor.execute("SELECT * FROM users WHERE id = " + user_id)  # Match

# 不应该匹配 (安全)
cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))  # No match
cursor.execute("SELECT * FROM users WHERE id = 1")  # No match
db.execute("SELECT * FROM users")  # No match (different cursor)
"""
```

### 规则库管理

```python
# 规则库管理
import yaml
from pathlib import Path
from typing import List, Dict

class RuleLibrary:
    """规则库管理"""
    
    def __init__(self, rules_dir: str):
        self.rules_dir = Path(rules_dir)
        self.rules = []
        self.load_rules()
    
    def load_rules(self):
        """加载规则"""
        for rule_file in self.rules_dir.glob('*.yml'):
            with open(rule_file) as f:
                rule_data = yaml.safe_load(f)
                if 'rules' in rule_data:
                    self.rules.extend(rule_data['rules'])
    
    def get_rules_by_severity(self, severity: str) -> List[Dict]:
        """按严重程度获取规则"""
        return [r for r in self.rules if r.get('severity') == severity]
    
    def get_rules_by_cwe(self, cwe_id: str) -> List[Dict]:
        """按 CWE 获取规则"""
        return [
            r for r in self.rules 
            if cwe_id in r.get('metadata', {}).get('cwe', '')
        ]
    
    def get_rules_by_owasp(self, owasp_id: str) -> List[Dict]:
        """按 OWASP 获取规则"""
        return [
            r for r in self.rules 
            if owasp_id in r.get('metadata', {}).get('owasp', '')
        ]
    
    def add_rule(self, rule: Dict):
        """添加规则"""
        # 验证规则
        self.validate_rule(rule)
        
        # 添加到规则库
        self.rules.append(rule)
        
        # 保存到文件
        self.save_rule(rule)
    
    def validate_rule(self, rule: Dict):
        """验证规则"""
        required_fields = ['id', 'patterns', 'message', 'languages']
        for field in required_fields:
            if field not in rule:
                raise ValueError(f"Rule missing required field: {field}")
        
        # 检查 ID 唯一性
        if any(r['id'] == rule['id'] for r in self.rules):
            raise ValueError(f"Rule ID already exists: {rule['id']}")
    
    def save_rule(self, rule: Dict):
        """保存规则到文件"""
        category = self.infer_category(rule)
        rule_file = self.rules_dir / f'{category}.yml'
        
        # 加载现有规则
        rules_data = {'rules': []}
        if rule_file.exists():
            with open(rule_file) as f:
                rules_data = yaml.safe_load(f)
        
        # 添加新规则
        rules_data['rules'].append(rule)
        
        # 保存
        with open(rule_file, 'w') as f:
            yaml.dump(rules_data, f, default_flow_style=False)
    
    def infer_category(self, rule: Dict) -> str:
        """推断规则类别"""
        rule_id = rule.get('id', '')
        
        if 'sql' in rule_id.lower():
            return 'sql-injection'
        elif 'xss' in rule_id.lower():
            return 'xss'
        elif 'command' in rule_id.lower():
            return 'command-injection'
        elif 'path' in rule_id.lower():
            return 'path-traversal'
        else:
            return 'general'
    
    def export_rules(self, format: str = 'semgrep') -> str:
        """导出规则"""
        if format == 'semgrep':
            return yaml.dump({'rules': self.rules}, default_flow_style=False)
        elif format == 'sonarqube':
            return self.convert_to_sonar_format()
        else:
            raise ValueError(f"Unsupported format: {format}")
    
    def convert_to_sonar_format(self) -> str:
        """转换为 SonarQube 格式"""
        # 实现转换逻辑
        pass
```

---

## 误报处理

### 误报原因

> ▎ 误报不是工具问题，是规则问题。规则不优化，误报就是持续的。

**误报常见原因**：
```
1. 规则过于宽泛
   - 匹配模式太通用
   - 没有考虑上下文
   - 缺少例外处理

2. 缺少语义理解
   - 无法理解代码意图
   - 无法识别清理函数
   - 无法追踪数据流

3. 框架特定模式
   - ORM 自动参数化
   - 模板自动转义
   - 框架安全机制

4. 测试代码
   - 测试数据不是真实输入
   - 测试代码不部署
   - 测试环境隔离
```

### 误报处理策略

```python
# 误报处理
class FalsePositiveHandler:
    """误报处理"""
    
    def __init__(self):
        # 误报规则
        self.fp_rules = {
            'orm_parameterized': self.is_orm_parameterized,
            'template_auto_escape': self.is_template_auto_escape,
            'test_code': self.is_test_code,
            'sanitized_input': self.is_sanitized_input
        }
    
    def filter_false_positives(self, issues):
        """过滤误报"""
        filtered = []
        
        for issue in issues:
            if not self.is_false_positive(issue):
                filtered.append(issue)
        
        return filtered
    
    def is_false_positive(self, issue):
        """判断是否误报"""
        for rule_name, rule_func in self.fp_rules.items():
            if rule_func(issue):
                return True
        
        return False
    
    def is_orm_parameterized(self, issue):
        """检查是否 ORM 参数化"""
        # ORM 自动参数化不是漏洞
        if 'filter(' in issue.get('code', ''):
            if 'exclude(' in issue.get('code', ''):
                return True
        
        # Django ORM
        if 'User.objects.filter' in issue.get('code', ''):
            return True
        
        # SQLAlchemy
        if '.filter_by(' in issue.get('code', ''):
            return True
        
        return False
    
    def is_template_auto_escape(self, issue):
        """检查是否模板自动转义"""
        # Jinja2 自动转义
        if 'render_template(' in issue.get('code', ''):
            return True
        
        # 除非明确禁用
        if 'autoescape=False' in issue.get('code', ''):
            return False
        
        return False
    
    def is_test_code(self, issue):
        """检查是否测试代码"""
        file_path = issue.get('file', '')
        
        # 测试目录
        if '/tests/' in file_path or '/test_' in file_path:
            return True
        
        # 测试文件
        if file_path.endswith('_test.py') or file_path.endswith('_spec.py'):
            return True
        
        return False
    
    def is_sanitized_input(self, issue):
        """检查输入是否已清理"""
        code = issue.get('code', '')
        
        # 检查清理函数
        sanitizers = ['escape(', 'sanitize(', 'quote(', 'parameterize(']
        for sanitizer in sanitizers:
            if sanitizer in code:
                return True
        
        return False
    
    def add_noqa_comment(self, issue):
        """添加 noqa 注释"""
        # 生成 noqa 注释
        noqa = f"# nosec {issue['id']}: {issue['reason']}"
        
        # 添加到代码
        # 实际实现需要修改源代码文件
        pass
    
    def generate_suppression_file(self, issues):
        """生成抑制文件"""
        suppression = {
            'suppressions': []
        }
        
        for issue in issues:
            if self.is_false_positive(issue):
                suppression['suppressions'].append({
                    'id': issue['id'],
                    'file': issue['file'],
                    'line': issue['line'],
                    'reason': issue.get('reason', 'False positive')
                })
        
        return suppression
```

---

## CI/CD 集成

### GitHub Actions 集成

```yaml
# .github/workflows/security-scan.yml
name: Security Scan

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  sast:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
      with:
        fetch-depth: 0
    
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'
    
    # Bandit
    - name: Run Bandit
      run: |
        pip install bandit
        bandit -r ./src -f json -o bandit-report.json || true
      continue-on-error: true
    
    # Semgrep
    - name: Run Semgrep
      run: |
        pip install semgrep
        semgrep --config auto --json ./src -o semgrep-report.json || true
      continue-on-error: true
    
    # Safety
    - name: Run Safety
      run: |
        pip install safety
        safety check --json --output safety-report.json || true
      continue-on-error: true
    
    # 上传报告
    - name: Upload Security Reports
      uses: actions/upload-artifact@v3
      with:
        name: security-reports
        path: |
          bandit-report.json
          semgrep-report.json
          safety-report.json
    
    # 生成汇总报告
    - name: Generate Summary
      run: |
        python scripts/generate_security_summary.py
    
    # 评论 PR
    - name: Comment PR
      if: github.event_name == 'pull_request'
      uses: actions/github-script@v6
      with:
        script: |
          const fs = require('fs');
          const summary = fs.readFileSync('security-summary.md', 'utf8');
          github.rest.issues.createComment({
            issue_number: context.issue.number,
            owner: context.repo.owner,
            repo: context.repo.repo,
            body: summary
          });
```

### GitLab CI 集成

```yaml
# .gitlab-ci.yml
stages:
  - test
  - security
  - deploy

# SAST 扫描
sast:
  stage: security
  image: python:3.11
  script:
    - pip install bandit semgrep safety
    - bandit -r ./src -f json -o $CI_PROJECT_DIR/bandit-report.json
    - semgrep --config auto --json ./src -o $CI_PROJECT_DIR/semgrep-report.json
    - safety check --json --output $CI_PROJECT_DIR/safety-report.json
  artifacts:
    reports:
      security: 
        - bandit-report.json
        - semgrep-report.json
        - safety-report.json
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

# 依赖扫描
dependency_scanning:
  stage: security
  image: python:3.11
  script:
    - pip install pip-audit
    - pip-audit --format json --output $CI_PROJECT_DIR/pip-audit-report.json
  artifacts:
    reports:
      dependency_scanning: pip-audit-report.json

# 安全门
security_gate:
  stage: security
  image: python:3.11
  script:
    - pip install semgrep
    - semgrep --config auto --error ./src
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
      when: always
    - when: manual
```

---

## 结果分析与修复

### 结果优先级

> ▎ 修复不是按数量，是按风险。风险不优先，资源就是浪费的。

**优先级模型**：
```python
# 结果优先级排序
class ResultPrioritizer:
    """结果优先级排序"""
    
    def prioritize(self, issues):
        """对问题进行优先级排序"""
        for issue in issues:
            issue['priority_score'] = self.calculate_priority(issue)
        
        # 按优先级排序
        issues.sort(key=lambda x: x['priority_score'], reverse=True)
        
        return issues
    
    def calculate_priority(self, issue):
        """计算优先级分数"""
        score = 0
        
        # 严重程度 (0-40 分)
        severity_scores = {
            'CRITICAL': 40,
            'ERROR': 30,
            'WARNING': 20,
            'INFO': 10
        }
        score += severity_scores.get(issue.get('severity', 'INFO'), 0)
        
        # 置信度 (0-30 分)
        confidence_scores = {
            'HIGH': 30,
            'MEDIUM': 20,
            'LOW': 10
        }
        score += confidence_scores.get(issue.get('confidence', 'LOW'), 0)
        
        # 可达性 (0-20 分)
        if issue.get('reachable', False):
            score += 20
        elif issue.get('potentially_reachable', False):
            score += 10
        
        # 代码热度 (0-10 分)
        # 经常被修改的代码优先级更高
        score += min(issue.get('code_churn', 0), 10)
        
        return score
    
    def get_remediation_order(self, issues):
        """获取修复顺序"""
        prioritized = self.prioritize(issues)
        
        # 分组
        groups = {
            'immediate': [],  # 立即修复
            'soon': [],       # 尽快修复
            'scheduled': [],  # 计划修复
            'backlog': []     # 待办
        }
        
        for issue in prioritized:
            if issue['priority_score'] >= 80:
                groups['immediate'].append(issue)
            elif issue['priority_score'] >= 60:
                groups['soon'].append(issue)
            elif issue['priority_score'] >= 40:
                groups['scheduled'].append(issue)
            else:
                groups['backlog'].append(issue)
        
        return groups
```

### 修复指南

```markdown
# 漏洞修复指南

## SQL 注入修复

### 问题代码
```python
cursor.execute("SELECT * FROM users WHERE id = %s" % user_id)
```

### 修复代码
```python
# 使用参数化查询
cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
```

### 修复说明
- 使用参数化查询而不是字符串拼接
- 参数作为元组传递给 execute()
- 数据库驱动会自动处理转义

## XSS 修复

### 问题代码
```python
return request.args.get('q')
```

### 修复代码
```python
from markupsafe import escape
return escape(request.args.get('q'))
```

### 修复说明
- 使用 escape() 转义用户输入
- 或使用模板引擎的自动转义
- 不要使用 Markup() 包装用户输入

## 命令注入修复

### 问题代码
```python
os.system(f"ping {hostname}")
```

### 修复代码
```python
import subprocess
subprocess.run(['ping', hostname], check=True)
```

### 修复说明
- 使用列表而不是字符串
- 不使用 shell=True
- 使用 subprocess 而不是 os.system
```

---

## 实战配置演练

### 完整配置示例

```yaml
# 完整 SAST 配置示例

# pyproject.toml
[tool.bandit]
targets = ["src"]
exclude_dirs = ["tests", "venv"]
skips = ["B101"]

[tool.semgrep]
config = [
    "auto",
    "p/python",
    "./rules/"
]
exclude = [
    "tests/",
    "venv/",
    "*.min.js"
]

# .sonarqube/conf/sonar-project.properties
sonar.projectKey=myproject
sonar.projectName=My Project
sonar.sources=src
sonar.tests=tests
sonar.python.coverage.reportPaths=coverage.xml
sonar.python.xunit.reportPath=test-results.xml
sonar.qualitygate.wait=true

# .github/workflows/security.yml
name: Security

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  security:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Setup Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'
    
    - name: Install dependencies
      run: |
        pip install bandit semgrep safety pip-audit
    
    - name: Run Bandit
      run: bandit -r ./src -f json -o bandit-report.json
      continue-on-error: true
    
    - name: Run Semgrep
      run: semgrep --config auto --json ./src -o semgrep-report.json
      continue-on-error: true
    
    - name: Run Safety
      run: safety check --json --output safety-report.json
      continue-on-error: true
    
    - name: Run pip-audit
      run: pip-audit --format json --output pip-audit-report.json
      continue-on-error: true
    
    - name: Upload Reports
      uses: actions/upload-artifact@v3
      with:
        name: security-reports
        path: "*.json"
```

---

统计 **Sprint 交付 · 绩效评估**
```
┌───────────────┬────────────────┬────────────────┐
│  主动出击   │ ██████████ 5/5 │ [PUA 生效] 充足 │
├───────────────┼────────────────┼────────────────┤
│ + 验证闭环   │ ██████████ 5/5 │ 案例完整       │
├───────────────┼────────────────┼────────────────┤
│ 设计 代码质量   │ ██████████ 5/5 │ 生产就绪       │
└───────────────┴────────────────┴────────────────┘
综合：4.5
```
▎ 这才配得上 P8。SAST 不是装工具，是建体系。体系不建立，安全就是表面的。

---

## 总结与思考

### 核心要点回顾

> ▎ 复盘四步法：回顾目标、评估结果、分析原因、总结经验。别跳过——这是闭环。

**SAST 框架**：
```
1. 工具选择
   - Bandit (Python)
   - Semgrep (多语言)
   - SonarQube (企业级)

2. 规则设计
   - 精确匹配
   - 减少误报
   - 持续更新

3. CI/CD 集成
   - 自动化扫描
   - 质量门禁
   - 报告汇总

4. 结果处理
   - 优先级排序
   - 误报过滤
   - 修复跟踪
```

**关键成功因素**：
```
1. 工具 + 流程
   - 工具发现问
   - 流程保落地
   - 两者缺一不可

2. 规则 + 人员
   - 规则自动化
   - 人员审结果
   - 互补非替代

3. 扫描 + 修复
   - 扫描是手段
   - 修复是目的
   - 闭环才有效
```

### 实战建议

> ▎ 我给你指了路，走不走是你的事。机会给了，抓不抓得住看你。

**SAST 建设**：
```
1. 从小开始
   - 先跑起来
   - 逐步优化
   - 快速见效

2. 规则优化
   - 减少误报
   - 增加覆盖
   - 持续迭代

3. 流程集成
   - CI/CD 集成
   - 质量门禁
   - 修复跟踪
```

---

## 参考资料

### 学习资源
```
- OWASP SAST Guide
  https://owasp.org/www-community/Source_Code_Analysis_Tools

- Semgrep Documentation
  https://semgrep.dev/docs/

- SonarQube Documentation
  https://docs.sonarqube.org/
```

### 工具资源
```
- Bandit
  https://github.com/PyCQA/bandit

- Semgrep
  https://github.com/returntocorp/semgrep

- CodeQL
  https://github.com/github/codeql
```

### 规则资源
```
- Semgrep Rule Registry
  https://semgrep.dev/explore

- SonarQube Rules
  https://rules.sonarsource.com/

- CWE Database
  https://cwe.mitre.org/
```

### 书籍推荐
```
- 《Static Analysis for Security》
- 《Secure Coding with SAST》
- 《Automated Security Testing》
```

---

**标记 明日预告**：Day 149 - 动态应用测试 DAST

> ▎ SAST 是静态分析，DAST 是动态测试——明天看动态应用测试 DAST。

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 148 篇，应用安全部分第 41 篇，精编版本*

*应用安全核心系列继续！*