Burp Suite Pro DevSecOps Integration — รวม DAST เข้ากับ CI/CD Pipeline

Burp Suite Pro คืออะไรและใช้ใน DevSecOps อย่างไร

Burp Suite Pro เป็น web application security testing platform จาก PortSwigger ที่ใช้กันแพร่หลายในวงการ penetration testing และ security assessment มี features หลักคือ Proxy สำหรับ intercept HTTP/HTTPS traffic, Scanner สำหรับ automated vulnerability scanning, Intruder สำหรับ fuzzing และ brute force, Repeater สำหรับ manual request manipulation และ Sequencer สำหรับ token analysis

ใน DevSecOps workflow Burp Suite Pro ถูกใช้เป็น DAST (Dynamic Application Security Testing) tool ที่ทดสอบ running applications หา vulnerabilities เช่น SQL Injection, XSS, CSRF, Authentication bypass และ Business logic flaws Burp Suite Pro มี REST API และ CI/CD integrations ที่ทำให้ automate การ scan ได้

ข้อดีของ Burp Suite เมื่อเทียบกับ DAST tools อื่นคือ ความแม่นยำสูง (low false positives), สามารถ crawl JavaScript-heavy SPAs ได้ดี, มี extensions ecosystem ใหญ่ (BApp Store), รองรับ authentication ที่ซับซ้อน และมี community ขนาดใหญ่

การรวม Burp Suite เข้ากับ DevSecOps pipeline ทำให้ทุก deployment ถูกตรวจสอบ security อัตโนมัติ พบ vulnerabilities เร็วขึ้น และลดภาระของ security team ที่ไม่ต้อง scan manually ทุกครั้ง

ตั้งค่า Burp Suite Pro สำหรับ Automated Scanning

ตั้งค่า Burp Suite Pro สำหรับ headless scanning และ API access

# ติดตั้ง Burp Suite Pro (headless mode)
# ดาวน์โหลดจาก https://portswigger.net/burp/releases

# รัน Burp Suite ใน headless mode
java -jar burpsuite_pro.jar \
  --project-file=project.burp \
  --config-file=scan-config.json \
  --unpause-spider-and-scanner

# scan-config.json — Configuration สำหรับ automated scanning
# {
#   "scanner": {
#     "active_scanning_optimization": {
#       "scan_speed": "fast",
#       "scan_accuracy": "normal"
#     },
#     "active_scanning_areas": {
#       "sql_injection": true,
#       "xss_reflected": true,
#       "xss_stored": true,
#       "command_injection": true,
#       "path_traversal": true,
#       "file_upload": true,
#       "xxe": true,
#       "ssrf": true,
#       "open_redirect": true,
#       "header_injection": true
#     },
#     "crawl_limits": {
#       "max_crawl_depth": 10,
#       "max_unique_locations": 5000,
#       "max_crawl_time": 3600
#     }
#   },
#   "project_options": {
#     "connections": {
#       "upstream_proxy": {
#         "use_upstream_proxy": false
#       },
#       "timeouts": {
#         "normal": 120,
#         "open_ended": 180
#       }
#     }
#   }
# }

# Burp Suite REST API (Enterprise/Pro)
# เปิด API: User Options -> Misc -> REST API
# Default port: 1337

# ตรวจสอบ API
curl -s http://localhost:1337/v0.1/ \
  -H "Authorization: Bearer YOUR_API_KEY"

# สร้าง scan ใหม่
curl -X POST http://localhost:1337/v0.1/scan \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://staging.example.com"],
    "scan_configurations": [
      {"name": "Crawl and Audit - Fast"}
    ]
  }'

# ตรวจสอบ status
curl -s http://localhost:1337/v0.1/scan/TASK_ID \
  -H "Authorization: Bearer YOUR_API_KEY"

# ดึง issues
curl -s http://localhost:1337/v0.1/scan/TASK_ID/issues \
  -H "Authorization: Bearer YOUR_API_KEY"

รวม Burp Suite เข้ากับ CI/CD Pipeline

GitHub Actions workflow สำหรับ automated DAST scanning

# .github/workflows/dast-burp.yml
name: DAST Security Scan with Burp Suite

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
  schedule:
    - cron: '0 2 * * 1'  # ทุกวันจันทร์ตี 2

jobs:
  deploy-staging:
    runs-on: ubuntu-latest
    outputs:
      staging_url: }
    steps:
      - uses: actions/checkout@v4
      - name: Deploy to staging
        id: deploy
        run: |
          # Deploy app to staging environment
          docker compose -f docker-compose.staging.yml up -d
          echo "url=http://staging.internal:8080" >> $GITHUB_OUTPUT
          sleep 30  # รอ app พร้อม

  burp-scan:
    needs: deploy-staging
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      
      - name: Install dependencies
        run: pip install requests jinja2
      
      - name: Start Burp Suite scan
        env:
          BURP_API_URL: }
          BURP_API_KEY: }
          TARGET_URL: }
        run: |
          python3 scripts/burp_ci_scan.py \
            --api-url "$BURP_API_URL" \
            --api-key "$BURP_API_KEY" \
            --target "$TARGET_URL" \
            --config "Crawl and Audit - Fast" \
            --timeout 3600 \
            --fail-on high, critical \
            --output burp-results.json
      
      - name: Generate HTML Report
        if: always()
        run: python3 scripts/burp_report.py burp-results.json burp-report.html
      
      - name: Upload Report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: burp-security-report
          path: |
            burp-results.json
            burp-report.html
      
      - name: Comment PR with results
        if: github.event_name == 'pull_request' && always()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const results = JSON.parse(fs.readFileSync('burp-results.json', 'utf8'));
            const critical = results.issues.filter(i => i.severity === 'high').length;
            const medium = results.issues.filter(i => i.severity === 'medium').length;
            const low = results.issues.filter(i => i.severity === 'low').length;
            
            const body = `## DAST Security Scan Results
            | Severity | Count |
            |----------|-------|
            | Critical/High |  |
            | Medium |  |
            | Low |  |
            
            
            `;
            
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: body
            });

# Jenkins Pipeline Alternative
# pipeline {
#   agent any
#   stages {
#     stage('DAST Scan') {
#       steps {
#         sh '''
#           python3 scripts/burp_ci_scan.py \
#             --target  \
#             --fail-on high
#         '''
#       }
#     }
#   }
# }

สร้าง Custom Extensions ด้วย Python

สร้าง Burp Suite extension สำหรับ custom security checks

#!/usr/bin/env python3
# burp_ci_scan.py — Burp Suite CI/CD Integration Script
import requests
import json
import time
import sys
import argparse

class BurpCIScanner:
    def __init__(self, api_url, api_key):
        self.api_url = api_url.rstrip("/")
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        }
    
    def create_scan(self, target_url, config_name="Crawl and Audit - Fast"):
        payload = {
            "urls": [target_url],
            "scan_configurations": [{"name": config_name}],
        }
        
        resp = requests.post(
            f"{self.api_url}/v0.1/scan",
            headers=self.headers,
            json=payload,
        )
        
        if resp.status_code == 201:
            task_id = resp.headers.get("Location", "").split("/")[-1]
            print(f"Scan created: task_id={task_id}")
            return task_id
        else:
            raise Exception(f"Failed to create scan: {resp.status_code} {resp.text}")
    
    def wait_for_scan(self, task_id, timeout=3600, poll_interval=30):
        start = time.time()
        
        while time.time() - start < timeout:
            resp = requests.get(
                f"{self.api_url}/v0.1/scan/{task_id}",
                headers=self.headers,
            )
            
            if resp.status_code != 200:
                raise Exception(f"Failed to get scan status: {resp.status_code}")
            
            data = resp.json()
            status = data.get("scan_status", "unknown")
            
            metrics = data.get("scan_metrics", {})
            crawl_count = metrics.get("crawl_requests_made", 0)
            audit_count = metrics.get("audit_requests_made", 0)
            
            print(f"Status: {status} | Crawled: {crawl_count} | Audited: {audit_count}")
            
            if status in ("succeeded", "failed", "paused"):
                return data
            
            time.sleep(poll_interval)
        
        raise TimeoutError(f"Scan did not complete within {timeout}s")
    
    def get_issues(self, task_id):
        resp = requests.get(
            f"{self.api_url}/v0.1/scan/{task_id}/issues",
            headers=self.headers,
        )
        
        if resp.status_code != 200:
            return []
        
        return resp.json().get("issues", [])
    
    def run_scan(self, target_url, config_name, timeout, fail_severities, output_file):
        task_id = self.create_scan(target_url, config_name)
        result = self.wait_for_scan(task_id, timeout)
        issues = self.get_issues(task_id)
        
        report = {
            "target": target_url,
            "scan_status": result.get("scan_status"),
            "scan_metrics": result.get("scan_metrics", {}),
            "issues": issues,
            "summary": self._summarize(issues),
        }
        
        with open(output_file, "w") as f:
            json.dump(report, f, indent=2)
        
        print(f"\nScan complete: {len(issues)} issues found")
        print(f"  High: {report['summary']['high']}")
        print(f"  Medium: {report['summary']['medium']}")
        print(f"  Low: {report['summary']['low']}")
        print(f"  Info: {report['summary']['info']}")
        
        # Check fail conditions
        for sev in fail_severities:
            if report["summary"].get(sev, 0) > 0:
                print(f"\nFAILED: {report['summary'][sev]} {sev} severity issues found")
                return False
        
        print("\nPASSED: No blocking issues found")
        return True
    
    def _summarize(self, issues):
        summary = {"high": 0, "medium": 0, "low": 0, "info": 0}
        for issue in issues:
            sev = issue.get("severity", "info").lower()
            summary[sev] = summary.get(sev, 0) + 1
        return summary

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Burp Suite CI Scanner")
    parser.add_argument("--api-url", required=True)
    parser.add_argument("--api-key", required=True)
    parser.add_argument("--target", required=True)
    parser.add_argument("--config", default="Crawl and Audit - Fast")
    parser.add_argument("--timeout", type=int, default=3600)
    parser.add_argument("--fail-on", default="high, critical")
    parser.add_argument("--output", default="burp-results.json")
    args = parser.parse_args()
    
    scanner = BurpCIScanner(args.api_url, args.api_key)
    fail_sevs = [s.strip() for s in args.fail_on.split(",")]
    
    success = scanner.run_scan(args.target, args.config, args.timeout, fail_sevs, args.output)
    sys.exit(0 if success else 1)

วิเคราะห์ผลลัพธ์และ Vulnerability Management

จัดการ vulnerabilities ที่พบจาก Burp Suite scanning

#!/usr/bin/env python3
# burp_report.py — Generate HTML Report from Burp Results
import json
import sys
from datetime import datetime

def generate_report(results_file, output_file):
    with open(results_file) as f:
        data = json.load(f)
    
    issues = data.get("issues", [])
    summary = data.get("summary", {})
    
    # จัดกลุ่ม issues ตาม severity
    grouped = {"high": [], "medium": [], "low": [], "info": []}
    for issue in issues:
        sev = issue.get("severity", "info").lower()
        grouped.setdefault(sev, []).append(issue)
    
    # สร้าง HTML report
    html = f"""




Target: {data.get('target', 'N/A')}
Date: {datetime.now().strftime('%Y-%m-%d %H:%M')}
Status: {data.get('scan_status', 'N/A')}



Medium

Low

Info


Issues Detail

"""
    
    for sev in ["high", "medium", "low", "info"]:
        for issue in grouped.get(sev, []):
            html += f"""\n"""
    
    html += """

Severity
Issue Type
URL
Confidence

{sev.upper()}
{issue.get('type_index', issue.get('name', 'N/A'))}
{issue.get('origin', '')}{issue.get('path', '')}
{issue.get('confidence', 'N/A')}

Remediation Priority

Fix all HIGH severity issues immediately
Address MEDIUM issues within current sprint
Plan LOW issues for next sprint
Review INFO items for false positives





"""
    
    with open(output_file, "w") as f:
        f.write(html)
    
    print(f"Report generated: {output_file}")

if __name__ == "__main__":
    generate_report(sys.argv[1], sys.argv[2])

Burp Suite API Automation Scripts

Scripts สำหรับ automate งาน security testing ที่ทำบ่อย

#!/bin/bash
# burp_automation.sh — Burp Suite Automation Toolkit
set -euo pipefail

BURP_API="http://localhost:1337"
API_KEY=""

# Function: สร้างและรอ scan จบ
run_scan() {
    local target="$1"
    local config=""
    
    echo "Starting scan: $target"
    
    # สร้าง scan
    task_id=$(curl -s -X POST "$BURP_API/v0.1/scan" \
        -H "Authorization: Bearer $API_KEY" \
        -H "Content-Type: application/json" \
        -d "{\"urls\":[\"$target\"],\"scan_configurations\":[{\"name\":\"$config\"}]}" \
        -o /dev/null -D - | grep -i location | awk -F'/' '{print $NF}' | tr -d '\r')
    
    echo "Task ID: $task_id"
    
    # รอจนจบ
    while true; do
        status=$(curl -s "$BURP_API/v0.1/scan/$task_id" \
            -H "Authorization: Bearer $API_KEY" | \
            python3 -c "import json, sys; print(json.load(sys.stdin).get('scan_status',''))")
        
        echo "Status: $status"
        
        if [ "$status" = "succeeded" ] || [ "$status" = "failed" ]; then
            break
        fi
        sleep 30
    done
    
    # ดึง results
    curl -s "$BURP_API/v0.1/scan/$task_id/issues" \
        -H "Authorization: Bearer $API_KEY" > "scan_.json"
    
    echo "Results saved: scan_.json"
}

# Function: Scan หลาย targets
batch_scan() {
    local targets_file="$1"
    
    while IFS= read -r url; do
        [ -z "$url" ] && continue
        echo "=== Scanning: $url ==="
        run_scan "$url" "Crawl and Audit - Lightweight"
        echo ""
    done < "$targets_file"
}

# Function: Compare scan results
diff_scans() {
    local old_scan="$1"
    local new_scan="$2"
    
    python3 - "$old_scan" "$new_scan" << 'PYEOF'
import json, sys

with open(sys.argv[1]) as f:
    old = set(json.dumps(i, sort_keys=True) for i in json.load(f).get("issues", []))
with open(sys.argv[2]) as f:
    new = set(json.dumps(i, sort_keys=True) for i in json.load(f).get("issues", []))

added = new - old
removed = old - new

print(f"New issues: {len(added)}")
print(f"Resolved: {len(removed)}")

for item in added:
    issue = json.loads(item)
    print(f"  [NEW] [{issue.get('severity','')}] {issue.get('name','')}")
PYEOF
}

# Usage
case "" in
    scan)   run_scan "$2" "" ;;
    batch)  batch_scan "$2" ;;
    diff)   diff_scans "$2" "$3" ;;
    *)      echo "Usage: $0 {scan|batch|diff} [args]" ;;
esac

FAQ คำถามที่พบบ่อย

Q: Burp Suite Community Edition ใช้ใน CI/CD ได้ไหม?

A: Community Edition มีข้อจำกัดที่สำคัญคือไม่มี REST API และไม่มี automated scanning features ที่ CI/CD ต้องการ ถ้าต้องการ DAST ฟรีสำหรับ CI/CD แนะนำใช้ OWASP ZAP ที่เป็น open source และมี CI/CD integrations ดีกว่า หรือใช้ Nuclei สำหรับ template-based scanning

Q: Burp Suite scan ใช้เวลานานแค่ไหน?

A: ขึ้นอยู่กับขนาดของ application และ configuration โดยเฉลี่ย Fast scan ใช้ 15-30 นาทีสำหรับ application ขนาดเล็ก (100 pages) Normal scan ใช้ 1-4 ชั่วโมง Thorough scan อาจใช้ 8-24 ชั่วโมง สำหรับ CI/CD แนะนำใช้ Fast scan เพื่อไม่ให้ pipeline ช้า แล้วรัน Thorough scan แยกตอนกลางคืน

Q: จะลด false positives ได้อย่างไร?

A: ใช้ scan configurations ที่เหมาะสมกับ technology stack เช่นถ้าเป็น React app ไม่ต้อง scan สำหรับ server-side template injection ตั้ง scope ให้ชัดเจนไม่ scan URLs ที่ไม่เกี่ยวข้อง สร้าง custom rules เพื่อ exclude known patterns และ review results เพื่อสร้าง baseline ที่ filter issues ซ้ำออก

Q: DAST กับ SAST ใช้อันเดียวพอไหม?

A: ไม่พอ SAST และ DAST ตรวจพบ vulnerabilities คนละประเภท SAST วิเคราะห์ source code หา issues เช่น hard-coded credentials, insecure functions DAST ทดสอบ running application หา issues เช่น misconfigurations, authentication bypass, runtime injection ควรใช้ทั้งสองเพื่อ coverage ที่ดีที่สุด เสริมด้วย SCA สำหรับ dependency vulnerabilities