Burp Suite Pro DevSecOps Integration — รวม DAST

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

เนื้อหาเกี่ยวข้อง — บทความที่เกี่ยวข้อง: คาppi คืออะไร — ทุกสิ่งที่ต้องรู้ในปี 2026

# ติดตั้ง 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

แนะนำเพิ่มเติม — iCafeForex

#!/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')}
เนื้อหาเกี่ยวข้อง — แนะนำให้อ่าน float python คือ — ข้อมูลครบถ้วน 2026

Status: {data.get('scan_status', 'N/A')}







Medium



Low



Info
แนะนำเพิ่มเติม — XM Signal





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 ที่ทำบ่อย

เนื้อหาเกี่ยวข้อง — ทำความเข้าใจ IS-IS Protocol FinOps Cloud Cost

#!/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 ได้อย่างไร?

เนื้อหาเกี่ยวข้อง — not your key not your coin

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