SAST セキュリティプラグイン

複数の言語、フレームワーク、セキュリティパターン全体にわたる包括的なコード脆弱性検出のための Static Application Security Testing (SAST)。

機能

• マルチ言語 SAST: Python、JavaScript/TypeScript、Java、Ruby、PHP、Go、Rust
• ツール統合: Bandit、Semgrep、ESLint Security、SonarQube、CodeQL、PMD、SpotBugs、Brakeman、gosec、cargo-clippy
• 脆弱性パターン: SQL インジェクション、XSS、ハードコードされたシークレット、パストラバーサル、IDOR、CSRF、安全でないデシリアライゼーション
• フレームワーク分析: Django、Flask、React、Express、Spring Boot、Rails、Laravel
• カスタムルール作成: 組織固有のセキュリティポリシーのための Semgrep パターン開発

このスキルを使う場合

コードレビューセキュリティ分析、インジェクション脆弱性、ハードコードされたシークレット、フレームワーク固有のパターン、カスタムセキュリティポリシーの実施、デプロイ前の検証、レガシーコード評価、およびコンプライアンス (OWASP、PCI-DSS、SOC2) に使用します。

専門的なツール: 高度な認証情報スキャンに security-secrets.md を、Top 10 マッピングに security-owasp.md を、REST/GraphQL エンドポイントに security-api.md を使用してください。

このスキルを使わない場合

• ランタイムテストまたはペネトレーションテストのみが必要な場合
• ソースコードまたはビルド出力にアクセスできない場合
• 環境がサードパーティのスキャンツールを禁止している場合

手順

1. スキャン対象の言語、フレームワーク、スコープを特定します。
2. SAST ツールを選択し、コードベース用のルールを構成します。
3. 再現可能な設定で CI またはローカルでスキャンを実行します。
4. 検出結果をトリアージし、重大度別に優先順位付けして、修正を提案します。

セキュリティ

• 承認なく、機密コードを外部サービスにアップロードしないようにしてください。
• 自動修正またはリリースのブロッキングを有効にする前に、レビューが必要です。

SAST ツール選択

Python: Bandit

# インストール & スキャン
pip install bandit
bandit -r . -f json -o bandit-report.json
bandit -r . -ll -ii -f json  # 高 / 重大のみ

構成: .bandit

exclude_dirs: ['/tests/', '/venv/', '/.tox/', '/build/']
tests: [B201, B301, B302, B303, B304, B305, B307, B308, B312, B323, B324, B501, B502, B506, B602, B608]
skips: [B101]

JavaScript/TypeScript: ESLint Security

npm install --save-dev eslint @eslint/plugin-security eslint-plugin-no-secrets
eslint . --ext .js,.jsx,.ts,.tsx --format json > eslint-security.json

構成: .eslintrc-security.json

{
  "plugins": ["@eslint/plugin-security", "eslint-plugin-no-secrets"],
  "extends": ["plugin:security/recommended"],
  "rules": {
    "security/detect-object-injection": "error",
    "security/detect-non-literal-fs-filename": "error",
    "security/detect-eval-with-expression": "error",
    "security/detect-pseudo-random-prng": "error",
    "no-secrets/no-secrets": "error"
  }
}

マルチ言語: Semgrep

pip install semgrep
semgrep --config=auto --json --output=semgrep-report.json
semgrep --config=p/security-audit --json
semgrep --config=p/owasp-top-ten --json
semgrep ci --config=auto  # CI モード

カスタムルール: .semgrep.yml

rules:
  - id: sql-injection-format-string
    pattern: cursor.execute("... %s ..." % $VAR)
    message: 文字列フォーマット経由の SQL インジェクション
    severity: ERROR
    languages: [python]
    metadata:
      cwe: "CWE-89"
      owasp: "A03:2021-Injection"

  - id: dangerous-innerHTML
    pattern: $ELEM.innerHTML = $VAR
    message: innerHTML 割り当て経由の XSS
    severity: ERROR
    languages: [javascript, typescript]
    metadata:
      cwe: "CWE-79"

  - id: hardcoded-aws-credentials
    patterns:
      - pattern: $KEY = "AKIA..."
      - metavariable-regex:
          metavariable: $KEY
          regex: "(aws_access_key_id|AWS_ACCESS_KEY_ID)"
    message: ハードコードされた AWS 認証情報が検出されました
    severity: ERROR
    languages: [python, javascript, java]

  - id: path-traversal-open
    patterns:
      - pattern: open($PATH, ...)
      - pattern-not: open(os.path.join(SAFE_DIR, ...), ...)
      - metavariable-pattern:
          metavariable: $PATH
          patterns:
            - pattern: $REQ.get(...)
    message: ユーザー入力経由のパストラバーサル
    severity: ERROR
    languages: [python]

  - id: command-injection
    patterns:
      - pattern-either:
          - pattern: os.system($CMD)
          - pattern: subprocess.call($CMD, shell=True)
      - metavariable-pattern:
          metavariable: $CMD
          patterns:
            - pattern-either:
                - pattern: $X + $Y
                - pattern: f"...{$VAR}..."
    message: shell=True 経由のコマンドインジェクション
    severity: ERROR
    languages: [python]

その他の言語ツール

Java: mvn spotbugs:check Ruby: brakeman -o report.json -f json Go: gosec -fmt=json -out=gosec.json ./... Rust: cargo clippy -- -W clippy::unwrap_used

脆弱性パターン

SQL インジェクション

脆弱: SQL クエリにおけるユーザー入力による文字列フォーマット/連結

安全:

# パラメータ化されたクエリ
cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
User.objects.filter(id=user_id)  # ORM

クロスサイトスクリプティング (XSS)

脆弱: サニタイズされていないユーザー入力による直接的な HTML 操作 (innerHTML、outerHTML、document.write)

安全:

// プレーンテキストに textContent を使用
element.textContent = userInput;

// React は自動的にエスケープ
<div>{userInput}</div>

// HTML が必要な場合はサニタイズ
import DOMPurify from 'dompurify';
element.innerHTML = DOMPurify.sanitize(userInput);

ハードコードされたシークレット

脆弱: ソースコード内のハードコードされた API キー、パスワード、トークン

安全:

import os
API_KEY = os.environ.get('API_KEY')
PASSWORD = os.getenv('DB_PASSWORD')

パストラバーサル

脆弱: サニタイズされていないユーザー入力を使用したファイルのオープン

安全:

import os
ALLOWED_DIR = '/var/www/uploads'
file_name = request.args.get('file')
file_path = os.path.join(ALLOWED_DIR, file_name)
file_path = os.path.realpath(file_path)
if not file_path.startswith(os.path.realpath(ALLOWED_DIR)):
    raise ValueError("Invalid file path")
with open(file_path, 'r') as f:
    content = f.read()

安全でないデシリアライゼーション

脆弱: 信頼できないデータでの pickle.loads()、yaml.load()

安全:

import json
data = json.loads(user_input)  # 安全
import yaml
config = yaml.safe_load(user_input)  # 安全

コマンドインジェクション

脆弱: os.system() またはユーザー入力付き shell=True での subprocess

安全:

subprocess.run(['ping', '-c', '4', user_input])  # 配列引数
import shlex
safe_input = shlex.quote(user_input)  # 入力検証

安全でないランダム生成

脆弱: セキュリティ重要な操作での random モジュール

安全:

import secrets
token = secrets.token_hex(16)
session_id = secrets.token_urlsafe(32)

フレームワークセキュリティ

Django

脆弱: @csrf_exempt、DEBUG=True、弱い SECRET_KEY、セキュリティミドルウェア不足

安全:

# settings.py
DEBUG = False
SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY')

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
X_FRAME_OPTIONS = 'DENY'

Flask

脆弱: debug=True、弱い secret_key、CORS ワイルドカード

安全:

import os
from flask_talisman import Talisman

app.secret_key = os.environ.get('FLASK_SECRET_KEY')
Talisman(app, force_https=True)
CORS(app, origins=['https://example.com'])

Express.js

脆弱: helmet 不足、CORS ワイルドカード、レート制限なし

安全:

const helmet = require('helmet');
const rateLimit = require('express-rate-limit');

app.use(helmet());
app.use(cors({ origin: 'https://example.com' }));
app.use(rateLimit({ windowMs: 15 * 60 * 1000, max: 100 }));

マルチ言語スキャナー実装

import json
import subprocess
from pathlib import Path
from typing import Dict, List, Any
from dataclasses import dataclass
from datetime import datetime

@dataclass
class SASTFinding:
    tool: str
    severity: str
    category: str
    title: str
    description: str
    file_path: str
    line_number: int
    cwe: str
    owasp: str
    confidence: str

class MultiLanguageSASTScanner:
    def __init__(self, project_path: str):
        self.project_path = Path(project_path)
        self.findings: List[SASTFinding] = []

    def detect_languages(self) -> List[str]:
        """言語の自動検出"""
        languages = []
        indicators = {
            'python': ['*.py', 'requirements.txt'],
            'javascript': ['*.js', 'package.json'],
            'typescript': ['*.ts', 'tsconfig.json'],
            'java': ['*.java', 'pom.xml'],
            'ruby': ['*.rb', 'Gemfile'],
            'go': ['*.go', 'go.mod'],
            'rust': ['*.rs', 'Cargo.toml'],
        }
        for lang, patterns in indicators.items():
            for pattern in patterns:
                if list(self.project_path.glob(f'**/{pattern}')):
                    languages.append(lang)
                    break
        return languages

    def run_comprehensive_sast(self) -> Dict[str, Any]:
        """すべての適用可能な SAST ツールを実行"""
        languages = self.detect_languages()

        scan_results = {
            'timestamp': datetime.now().isoformat(),
            'languages': languages,
            'tools_executed': [],
            'findings': []
        }

        self.run_semgrep_scan()
        scan_results['tools_executed'].append('semgrep')

        if 'python' in languages:
            self.run_bandit_scan()
            scan_results['tools_executed'].append('bandit')
        if 'javascript' in languages or 'typescript' in languages:
            self.run_eslint_security_scan()
            scan_results['tools_executed'].append('eslint-security')

        scan_results['findings'] = [vars(f) for f in self.findings]
        scan_results['summary'] = self.generate_summary()
        return scan_results

    def run_semgrep_scan(self):
        """Semgrep を実行"""
        for ruleset in ['auto', 'p/security-audit', 'p/owasp-top-ten']:
            try:
                result = subprocess.run([
                    'semgrep', '--config', ruleset, '--json', '--quiet',
                    str(self.project_path)
                ], capture_output=True, text=True, timeout=300)

                if result.stdout:
                    data = json.loads(result.stdout)
                    for f in data.get('results', []):
                        self.findings.append(SASTFinding(
                            tool='semgrep',
                            severity=f.get('extra', {}).get('severity', 'MEDIUM').upper(),
                            category='sast',
                            title=f.get('check_id', ''),
                            description=f.get('extra', {}).get('message', ''),
                            file_path=f.get('path', ''),
                            line_number=f.get('start', {}).get('line', 0),
                            cwe=f.get('extra', {}).get('metadata', {}).get('cwe', ''),
                            owasp=f.get('extra', {}).get('metadata', {}).get('owasp', ''),
                            confidence=f.get('extra', {}).get('metadata', {}).get('confidence', 'MEDIUM')
                        ))
            except Exception as e:
                print(f"Semgrep {ruleset} failed: {e}")

    def generate_summary(self) -> Dict[str, Any]:
        """統計を生成"""
        severity_counts = {'CRITICAL': 0, 'HIGH': 0, 'MEDIUM': 0, 'LOW': 0}
        for f in self.findings:
            severity_counts[f.severity] = severity_counts.get(f.severity, 0) + 1

        return {
            'total_findings': len(self.findings),
            'severity_breakdown': severity_counts,
            'risk_score': self.calculate_risk_score(severity_counts)
        }

    def calculate_risk_score(self, severity_counts: Dict[str, int]) -> int:
        """リスクスコア 0-100"""
        weights = {'CRITICAL': 10, 'HIGH': 7, 'MEDIUM': 4, 'LOW': 1}
        total = sum(weights[s] * c for s, c in severity_counts.items())
        return min(100, int((total / 50) * 100))

CI/CD 統合

GitHub Actions

name: SAST Scan
on:
  pull_request:
    branches: [main]

jobs:
  sast:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: ツールのインストール
        run: |
          pip install bandit semgrep
          npm install -g eslint @eslint/plugin-security

      - name: スキャンを実行
        run: |
          bandit -r . -f json -o bandit.json || true
          semgrep --config=auto --json --output=semgrep.json || true

      - name: レポートをアップロード
        uses: actions/upload-artifact@v3
        with:
          name: sast-reports
          path: |
            bandit.json
            semgrep.json

GitLab CI

sast:
  stage: test
  image: python:3.11
  script:
    - pip install bandit semgrep
    - bandit -r . -f json -o bandit.json || true
    - semgrep --config=auto --json --output=semgrep.json || true
  artifacts:
    reports:
      sast: bandit.json

ベストプラクティス

1. 早期かつ頻繁に実行 - プリコミットフックと CI/CD
2. 複数ツールを組み合わせる - 異なるツールは異なる脆弱性を検出
3. 誤検知を調整 - 除外と閾値を構成
4. 検出結果を優先順位付け - まず CRITICAL/HIGH に焦点を当てる
5. フレームワーク対応スキャン - 特定のルールセットを使用
6. カスタムルール - 組織固有のパターン
7. 開発者トレーニング - セキュアコーディングプラクティス
8. 段階的な修復 - 段階的に修正
9. ベースライン管理 - 既知の問題を追跡
10. 定期的な更新 - ツールを最新の状態に保つ

関連ツール

• security-secrets.md - 高度な認証情報検出
• security-owasp.md - OWASP Top 10 評価
• security-api.md - API セキュリティテスト
• security-scan.md - 包括的なセキュリティスキャン

制限事項

• このスキルは、タスクが上記のスコープと明確に一致する場合にのみ使用してください。
• 出力を環境固有の検証、テスト、または専門家による審査の代わりとは見なさないでください。
• 必要な入力、権限、セキュリティ境界、または成功基準が不明な場合は、停止して説明を求めてください。