🔍 OWASP ZAP이 뭐길래?

OWASP ZAP은 Open Web Application Security Project에서 만든 무료 보안 테스팅 도구야. 쉽게 말하면 웹사이트나 웹 애플리케이션의 보안 취약점을 찾아주는 친구라고 생각하면 돼. 🕵️

일반적으로 보안 테스트를 수동으로 하려면 엄청난 시간과 노력이 필요해. 매번 같은 테스트를 반복하는 건 정말 지루하고 비효율적이지. 그래서 등장한 게 바로 자동화 스크립팅이야!

🚀 ZAP 자동화의 핵심 개념

ZAP 자동화를 이해하려면 먼저 몇 가지 핵심 개념을 알아야 해. 어렵지 않으니까 천천히 따라와봐! 😊

1. ZAP API - 자동화의 시작점

ZAP API는 ZAP의 모든 기능을 프로그래밍 방식으로 제어할 수 있게 해주는 인터페이스야. REST API 형태로 제공되기 때문에 어떤 프로그래밍 언어에서든 HTTP 요청만 보낼 수 있으면 사용할 수 있어.

2. ZAP 데몬 모드

자동화를 위해서는 ZAP을 데몬(백그라운드) 모드로 실행해야 해. GUI 없이 명령줄에서 실행되는 방식이지. 이렇게 하면 서버 환경이나 CI/CD 파이프라인에서도 ZAP을 사용할 수 있어! 🖥️

# ZAP 데몬 모드로 실행하기
zap.sh -daemon -host 0.0.0.0 -port 8080 -config api.key=your-api-key-here

3. 컨텍스트(Context)와 세션(Session)

ZAP에서 컨텍스트는 테스트할 웹 애플리케이션의 범위를 정의하는 거야. 어떤 URL을 포함하고 제외할지, 인증은 어떻게 할지 등을 설정하지. 세션은 이런 설정들을 저장하고 재사용할 수 있게 해줘.

🛠️ 환경 설정하기

자, 이제 본격적으로 ZAP 자동화 환경을 구축해보자! 단계별로 차근차근 진행할게. 📝

Step 1: ZAP 설치

ZAP은 Windows, macOS, Linux 모두에서 사용할 수 있어. 공식 웹사이트(www.zaproxy.org)에서 다운로드할 수 있지.

Step 2: Python 환경 구성

Python으로 ZAP을 제어하는 게 가장 인기 있는 방법이야. Python ZAP 클라이언트 라이브러리를 설치해보자!

# Python ZAP 라이브러리 설치
pip install python-owasp-zap-v2.4

# 추가로 유용한 라이브러리들
pip install requests
pip install python-dotenv  # 환경변수 관리용

Step 3: API 키 설정

보안을 위해 ZAP API는 API 키를 요구해. ZAP을 처음 실행하면 자동으로 생성되는데, 이걸 확인하고 저장해두자.

# .env 파일 예시
ZAP_API_KEY=your-secret-api-key-here
ZAP_HOST=localhost
ZAP_PORT=8080
TARGET_URL=https://example.com

💻 첫 번째 자동화 스크립트 작성하기

드디어 실제 코드를 작성할 시간이야! 가장 기본적인 스캔 자동화 스크립트부터 시작해보자. 🎨

기본 스캔 스크립트

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import time
import os
from zapv2 import ZAPv2
from dotenv import load_dotenv

# 환경변수 로드
load_dotenv()

# ZAP 설정
ZAP_API_KEY = os.getenv('ZAP_API_KEY')
ZAP_HOST = os.getenv('ZAP_HOST', 'localhost')
ZAP_PORT = int(os.getenv('ZAP_PORT', 8080))
TARGET_URL = os.getenv('TARGET_URL')

# ZAP 인스턴스 생성
zap = ZAPv2(
    apikey=ZAP_API_KEY,
    proxies={
        'http': f'http://{ZAP_HOST}:{ZAP_PORT}',
        'https': f'http://{ZAP_HOST}:{ZAP_PORT}'
    }
)

def main():
    print(f"🚀 ZAP 자동화 스캔 시작!")
    print(f"📍 대상 URL: {TARGET_URL}")
    
    # 1. 새 세션 시작
    print("\n✨ 새 세션 생성 중...")
    zap.core.new_session()
    
    # 2. Spider 실행 (사이트 크롤링)
    print("\n🕷️ Spider 크롤링 시작...")
    scan_id = zap.spider.scan(TARGET_URL)
    
    # Spider 진행상황 모니터링
    while int(zap.spider.status(scan_id)) < 100:
        progress = zap.spider.status(scan_id)
        print(f"Spider 진행률: {progress}%")
        time.sleep(2)
    
    print("✅ Spider 크롤링 완료!")
    
    # 3. Passive Scan 대기
    print("\n🔍 Passive Scan 진행 중...")
    while int(zap.pscan.records_to_scan) > 0:
        records = zap.pscan.records_to_scan
        print(f"남은 레코드: {records}")
        time.sleep(2)
    
    print("✅ Passive Scan 완료!")
    
    # 4. Active Scan 실행
    print("\n⚡ Active Scan 시작...")
    scan_id = zap.ascan.scan(TARGET_URL)
    
    # Active Scan 진행상황 모니터링
    while int(zap.ascan.status(scan_id)) < 100:
        progress = zap.ascan.status(scan_id)
        print(f"Active Scan 진행률: {progress}%")
        time.sleep(5)
    
    print("✅ Active Scan 완료!")
    
    # 5. 결과 수집
    print("\n📊 스캔 결과 수집 중...")
    alerts = zap.core.alerts(baseurl=TARGET_URL)
    
    # 심각도별 분류
    high_alerts = [a for a in alerts if a['risk'] == 'High']
    medium_alerts = [a for a in alerts if a['risk'] == 'Medium']
    low_alerts = [a for a in alerts if a['risk'] == 'Low']
    info_alerts = [a for a in alerts if a['risk'] == 'Informational']
    
    # 결과 출력
    print("\n" + "="*50)
    print("🎯 스캔 결과 요약")
    print("="*50)
    print(f"🔴 High: {len(high_alerts)}개")
    print(f"🟡 Medium: {len(medium_alerts)}개")
    print(f"🟢 Low: {len(low_alerts)}개")
    print(f"ℹ️  Info: {len(info_alerts)}개")
    print("="*50)
    
    # High 알림 상세 출력
    if high_alerts:
        print("\n⚠️ 심각한 취약점 발견!")
        for alert in high_alerts:
            print(f"\n제목: {alert['alert']}")
            print(f"URL: {alert['url']}")
            print(f"설명: {alert['description'][:100]}...")
    
    # 6. HTML 리포트 생성
    print("\n📄 HTML 리포트 생성 중...")
    html_report = zap.core.htmlreport()
    
    report_filename = f"zap_report_{time.strftime('%Y%m%d_%H%M%S')}.html"
    with open(report_filename, 'w', encoding='utf-8') as f:
        f.write(html_report)
    
    print(f"✅ 리포트 저장 완료: {report_filename}")
    print("\n🎉 모든 작업 완료!")

if __name__ == "__main__":
    main()

이 스크립트는 ZAP 자동화의 기본 흐름을 보여줘. Spider로 사이트를 크롤링하고, Passive Scan과 Active Scan을 순차적으로 실행한 다음, 결과를 수집하고 리포트를 생성하는 거지! 🎯

🎯 고급 자동화 기법

기본을 마스터했다면 이제 좀 더 고급 기능들을 알아볼 차례야! 실무에서 정말 유용한 테크닉들이니까 집중해봐. 🔥

1. 인증이 필요한 애플리케이션 테스트

대부분의 웹 애플리케이션은 로그인이 필요하지? ZAP에서 인증을 자동화하는 방법을 알아보자!

def setup_authentication(zap, target_url, context_name):
    """
    폼 기반 인증 설정
    """
    print("🔐 인증 설정 중...")
    
    # 컨텍스트 생성
    context_id = zap.context.new_context(context_name)
    
    # URL을 컨텍스트에 포함
    zap.context.include_in_context(context_name, f"{target_url}.*")
    
    # 로그인 페이지 설정
    login_url = f"{target_url}/login"
    zap.authentication.set_authentication_method(
        contextid=context_id,
        authmethodname='formBasedAuthentication',
        authmethodconfigparams=f'loginUrl={login_url}&loginRequestData=username={{%username%}}&password={{%password%}}'
    )
    
    # 사용자 추가
    user_id = zap.users.new_user(context_id, 'test_user')
    zap.users.set_authentication_credentials(
        contextid=context_id,
        userid=user_id,
        authcredentialsconfigparams='username=testuser&password=testpass123'
    )
    
    # 사용자 활성화
    zap.users.set_user_enabled(context_id, user_id, True)
    
    print("✅ 인증 설정 완료!")
    return context_id, user_id

2. 스캔 정책 커스터마이징

모든 취약점을 다 검사하면 시간이 너무 오래 걸려. 필요한 것만 선택적으로 스캔하는 방법이야!

def create_custom_scan_policy(zap, policy_name):
    """
    커스텀 스캔 정책 생성
    """
    print(f"⚙️ 커스텀 스캔 정책 '{policy_name}' 생성 중...")
    
    # 모든 스캐너 비활성화
    scanners = zap.ascan.scanners()
    for scanner in scanners:
        zap.ascan.set_scanner_alert_threshold(
            id=scanner['id'],
            alertthreshold='OFF'
        )
    
    # 중요한 스캐너만 활성화
    important_scanners = [
        '40012',  # Cross Site Scripting (Reflected)
        '40014',  # Cross Site Scripting (Persistent)
        '40018',  # SQL Injection
        '90019',  # Server Side Code Injection
        '90020',  # Remote OS Command Injection
    ]
    
    for scanner_id in important_scanners:
        zap.ascan.set_scanner_alert_threshold(
            id=scanner_id,
            alertthreshold='MEDIUM'
        )
        zap.ascan.set_scanner_attack_strength(
            id=scanner_id,
            attackstrength='HIGH'
        )
    
    print("✅ 스캔 정책 설정 완료!")
    print(f"활성화된 스캐너: {len(important_scanners)}개")

3. Ajax Spider 활용

요즘 웹사이트는 대부분 JavaScript를 많이 사용하잖아? 일반 Spider로는 찾지 못하는 페이지들을 Ajax Spider로 찾을 수 있어! 🕸️

def run_ajax_spider(zap, target_url):
    """
    Ajax Spider 실행 (JavaScript 기반 애플리케이션용)
    """
    print("🌐 Ajax Spider 시작...")
    
    # Ajax Spider 설정
    zap.ajaxSpider.set_option_max_duration('10')  # 최대 10분
    zap.ajaxSpider.set_option_number_of_browsers('2')  # 브라우저 2개 사용
    
    # Ajax Spider 실행
    zap.ajaxSpider.scan(target_url)
    
    # 진행상황 모니터링
    while zap.ajaxSpider.status == 'running':
        print(f"Ajax Spider 실행 중... (발견된 URL: {zap.ajaxSpider.number_of_results})")
        time.sleep(5)
    
    print(f"✅ Ajax Spider 완료! 총 {zap.ajaxSpider.number_of_results}개 URL 발견")
    
    # 발견된 URL 목록 반환
    return zap.ajaxSpider.results()

🔄 CI/CD 파이프라인 통합

진짜 자동화의 힘은 CI/CD 파이프라인에 통합할 때 발휘돼! 코드가 커밋될 때마다 자동으로 보안 테스트가 실행되는 거지. 🚀

Jenkins 통합 예시

pipeline {
    agent any
    
    environment {
        ZAP_HOST = 'localhost'
        ZAP_PORT = '8080'
        TARGET_URL = 'https://staging.example.com'
    }
    
    stages {
        stage('Start ZAP') {
            steps {
                script {
                    // ZAP 데몬 시작
                    sh '''
                        docker run -d --name zap \
                        -p 8080:8080 \
                        -v $(pwd):/zap/wrk/:rw \
                        owasp/zap2docker-stable \
                        zap.sh -daemon -host 0.0.0.0 -port 8080 \
                        -config api.key=${ZAP_API_KEY}
                    '''
                    sleep(time: 30, unit: 'SECONDS')
                }
            }
        }
        
        stage('Run Security Scan') {
            steps {
                script {
                    sh 'python3 zap_automation.py'
                }
            }
        }
        
        stage('Generate Report') {
            steps {
                script {
                    // HTML 리포트 아카이브
                    archiveArtifacts artifacts: 'zap_report_*.html'
                    
                    // 취약점이 발견되면 빌드 실패
                    sh '''
                        python3 check_vulnerabilities.py
                    '''
                }
            }
        }
    }
    
    post {
        always {
            // ZAP 컨테이너 정리
            sh 'docker stop zap && docker rm zap'
        }
        failure {
            // 실패 시 알림
            emailext (
                subject: "보안 스캔 실패: ${env.JOB_NAME}",
                body: "보안 취약점이 발견되었습니다. 리포트를 확인하세요.",
                to: "security-team@example.com"
            )
        }
    }
}

GitHub Actions 통합 예시

name: Security Scan with ZAP

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

jobs:
  zap-scan:
    runs-on: ubuntu-latest
    
    steps:
    - name: Checkout code
      uses: actions/checkout@v2
    
    - name: Setup Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    
    - name: Install dependencies
      run: |
        pip install python-owasp-zap-v2.4
        pip install requests
    
    - name: Run ZAP Docker
      run: |
        docker run -d --name zap \
        -p 8080:8080 \
        owasp/zap2docker-stable \
        zap.sh -daemon -host 0.0.0.0 -port 8080 \
        -config api.disablekey=true
        sleep 30
    
    - name: Run ZAP Scan
      env:
        TARGET_URL: ${{ secrets.TARGET_URL }}
      run: python3 zap_automation.py
    
    - name: Upload Report
      uses: actions/upload-artifact@v2
      with:
        name: zap-report
        path: zap_report_*.html
    
    - name: Check Vulnerabilities
      run: python3 check_vulnerabilities.py
    
    - name: Stop ZAP
      if: always()
      run: docker stop zap && docker rm zap

📊 결과 분석과 리포팅

스캔을 실행하는 것도 중요하지만, 결과를 제대로 분석하고 리포트하는 것도 엄청 중요해! 📈

결과 필터링과 분류

def analyze_scan_results(zap, target_url):
    """
    스캔 결과를 분석하고 분류
    """
    print("📊 스캔 결과 분석 중...")
    
    # 모든 알림 가져오기
    alerts = zap.core.alerts(baseurl=target_url)
    
    # 심각도별 분류
    severity_counts = {
        'High': 0,
        'Medium': 0,
        'Low': 0,
        'Informational': 0
    }
    
    # 취약점 타입별 분류
    vulnerability_types = {}
    
    for alert in alerts:
        # 심각도 카운트
        severity_counts[alert['risk']] += 1
        
        # 타입별 분류
        alert_name = alert['alert']
        if alert_name not in vulnerability_types:
            vulnerability_types[alert_name] = {
                'count': 0,
                'urls': [],
                'risk': alert['risk']
            }
        
        vulnerability_types[alert_name]['count'] += 1
        vulnerability_types[alert_name]['urls'].append(alert['url'])
    
    # 결과 출력
    print("\n" + "="*60)
    print("📈 스캔 결과 상세 분석")
    print("="*60)
    
    print("\n🎯 심각도별 통계:")
    for severity, count in severity_counts.items():
        emoji = {'High': '🔴', 'Medium': '🟡', 'Low': '🟢', 'Informational': 'ℹ️'}
        print(f"{emoji[severity]} {severity}: {count}개")
    
    print("\n🔍 취약점 타입별 통계:")
    sorted_vulns = sorted(
        vulnerability_types.items(),
        key=lambda x: x[1]['count'],
        reverse=True
    )
    
    for vuln_name, vuln_data in sorted_vulns[:10]:  # 상위 10개만
        print(f"\n• {vuln_name}")
        print(f"  - 발견 횟수: {vuln_data['count']}회")
        print(f"  - 심각도: {vuln_data['risk']}")
        print(f"  - 영향받는 URL: {len(vuln_data['urls'])}개")
    
    return {
        'severity_counts': severity_counts,
        'vulnerability_types': vulnerability_types,
        'total_alerts': len(alerts)
    }

커스텀 리포트 생성

ZAP의 기본 리포트도 좋지만, 팀에 맞는 커스텀 리포트를 만들면 더 유용해!

import json
from datetime import datetime

def generate_custom_report(analysis_results, target_url, output_format='json'):
    """
    커스텀 리포트 생성
    """
    report_data = {
        'scan_info': {
            'target_url': target_url,
            'scan_date': datetime.now().isoformat(),
            'total_vulnerabilities': analysis_results['total_alerts']
        },
        'severity_summary': analysis_results['severity_counts'],
        'vulnerability_details': analysis_results['vulnerability_types']
    }
    
    if output_format == 'json':
        filename = f"custom_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(report_data, f, indent=2, ensure_ascii=False)
        print(f"✅ JSON 리포트 생성: {filename}")
    
    elif output_format == 'markdown':
        filename = f"custom_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(f"# 보안 스캔 리포트\n\n")
            f.write(f"**대상 URL:** {target_url}\n")
            f.write(f"**스캔 일시:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
            
            f.write("## 심각도별 요약\n\n")
            for severity, count in report_data['severity_summary'].items():
                f.write(f"- **{severity}:** {count}개\n")
            
            f.write("\n## 취약점 상세\n\n")
            for vuln_name, vuln_data in report_data['vulnerability_details'].items():
                f.write(f"### {vuln_name}\n")
                f.write(f"- 심각도: {vuln_data['risk']}\n")
                f.write(f"- 발견 횟수: {vuln_data['count']}회\n\n")
        
        print(f"✅ Markdown 리포트 생성: {filename}")
    
    return filename

🎨 실전 활용 시나리오

이론은 충분히 배웠으니, 이제 실제 상황에서 어떻게 활용하는지 알아보자! 💼

시나리오 1: 정기 보안 점검 자동화

매주 월요일 오전 2시에 자동으로 보안 스캔을 실행하고 결과를 이메일로 받는 시스템이야.

import schedule
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders

def weekly_security_scan():
    """
    주간 정기 보안 스캔
    """
    print("🗓️ 주간 정기 보안 스캔 시작...")
    
    # ZAP 스캔 실행
    zap = initialize_zap()
    run_full_scan(zap, TARGET_URL)
    
    # 결과 분석
    results = analyze_scan_results(zap, TARGET_URL)
    
    # 리포트 생성
    report_file = generate_custom_report(results, TARGET_URL, 'markdown')
    
    # 이메일 발송
    send_email_report(
        subject=f"주간 보안 스캔 리포트 - {datetime.now().strftime('%Y-%m-%d')}",
        body=f"이번 주 보안 스캔이 완료되었습니다.\n\n"
             f"총 {results['total_alerts']}개의 이슈가 발견되었습니다.\n"
             f"상세 내용은 첨부 파일을 확인하세요.",
        attachment=report_file
    )
    
    print("✅ 주간 보안 스캔 완료 및 리포트 발송!")

def send_email_report(subject, body, attachment):
    """
    이메일로 리포트 발송
    """
    msg = MIMEMultipart()
    msg['From'] = 'security-bot@example.com'
    msg['To'] = 'security-team@example.com'
    msg['Subject'] = subject
    
    msg.attach(MIMEText(body, 'plain'))
    
    # 첨부파일 추가
    with open(attachment, 'rb') as f:
        part = MIMEBase('application', 'octet-stream')
        part.set_payload(f.read())
        encoders.encode_base64(part)
        part.add_header('Content-Disposition', f'attachment; filename={attachment}')
        msg.attach(part)
    
    # SMTP 서버로 전송
    server = smtplib.SMTP('smtp.example.com', 587)
    server.starttls()
    server.login('security-bot@example.com', 'password')
    server.send_message(msg)
    server.quit()

# 스케줄 설정
schedule.every().monday.at("02:00").do(weekly_security_scan)

# 스케줄러 실행
while True:
    schedule.run_pending()
    time.sleep(60)

시나리오 2: API 엔드포인트 보안 테스트

REST API의 각 엔드포인트를 자동으로 테스트하는 스크립트야. API 개발할 때 정말 유용해! 🔌

def test_api_endpoints(zap, base_url, api_spec):
    """
    OpenAPI/Swagger 스펙 기반 API 테스트
    """
    print("🔌 API 엔드포인트 보안 테스트 시작...")
    
    # OpenAPI 스펙 임포트
    zap.openapi.import_url(api_spec)
    
    # 각 엔드포인트별 테스트
    endpoints = [
        {'method': 'GET', 'path': '/api/users'},
        {'method': 'POST', 'path': '/api/users'},
        {'method': 'GET', 'path': '/api/users/{id}'},
        {'method': 'PUT', 'path': '/api/users/{id}'},
        {'method': 'DELETE', 'path': '/api/users/{id}'},
    ]
    
    results = {}
    
    for endpoint in endpoints:
        url = f"{base_url}{endpoint['path']}"
        print(f"\n테스트 중: {endpoint['method']} {url}")
        
        # Active Scan 실행
        scan_id = zap.ascan.scan(url)
        
        # 스캔 완료 대기
        while int(zap.ascan.status(scan_id)) < 100:
            time.sleep(2)
        
        # 결과 수집
        alerts = zap.core.alerts(baseurl=url)
        results[f"{endpoint['method']} {endpoint['path']}"] = {
            'alert_count': len(alerts),
            'high_risk': len([a for a in alerts if a['risk'] == 'High']),
            'alerts': alerts
        }
        
        print(f"✅ 완료: {len(alerts)}개 이슈 발견")
    
    # 결과 요약
    print("\n" + "="*60)
    print("📊 API 엔드포인트 테스트 결과")
    print("="*60)
    
    for endpoint, data in results.items():
        print(f"\n{endpoint}")
        print(f"  총 이슈: {data['alert_count']}개")
        print(f"  High 위험: {data['high_risk']}개")
    
    return results

시나리오 3: 회귀 테스트 (Regression Testing)

이전 스캔 결과와 비교해서 새로운 취약점이 생겼는지 확인하는 거야!

def regression_test(zap, target_url, baseline_file):
    """
    회귀 테스트 - 이전 결과와 비교
    """
    print("🔄 회귀 테스트 시작...")
    
    # 현재 스캔 실행
    current_results = run_full_scan(zap, target_url)
    current_alerts = zap.core.alerts(baseurl=target_url)
    
    # 베이스라인 로드
    with open(baseline_file, 'r') as f:
        baseline_alerts = json.load(f)
    
    # 새로운 취약점 찾기
    new_vulnerabilities = []
    fixed_vulnerabilities = []
    
    current_alert_ids = {alert['alert'] + alert['url'] for alert in current_alerts}
    baseline_alert_ids = {alert['alert'] + alert['url'] for alert in baseline_alerts}
    
    # 새로 발견된 취약점
    for alert in current_alerts:
        alert_id = alert['alert'] + alert['url']
        if alert_id not in baseline_alert_ids:
            new_vulnerabilities.append(alert)
    
    # 수정된 취약점
    for alert in baseline_alerts:
        alert_id = alert['alert'] + alert['url']
        if alert_id not in current_alert_ids:
            fixed_vulnerabilities.append(alert)
    
    # 결과 출력
    print("\n" + "="*60)
    print("🔄 회귀 테스트 결과")
    print("="*60)
    print(f"✨ 새로 발견된 취약점: {len(new_vulnerabilities)}개")
    print(f"✅ 수정된 취약점: {len(fixed_vulnerabilities)}개")
    
    if new_vulnerabilities:
        print("\n⚠️ 새로운 취약점 상세:")
        for vuln in new_vulnerabilities:
            print(f"  • {vuln['alert']} ({vuln['risk']})")
            print(f"    URL: {vuln['url']}")
    
    if fixed_vulnerabilities:
        print("\n🎉 수정된 취약점:")
        for vuln in fixed_vulnerabilities:
            print(f"  • {vuln['alert']}")
    
    # 현재 결과를 새 베이스라인으로 저장
    with open(baseline_file, 'w') as f:
        json.dump(current_alerts, f, indent=2)
    
    return {
        'new': new_vulnerabilities,
        'fixed': fixed_vulnerabilities
    }

⚡ 성능 최적화 팁

ZAP 스캔은 시간이 오래 걸릴 수 있어. 효율적으로 만드는 방법들을 알아보자! ⏱️

zap.context.exclude_from_context(
    'MyContext',
    '.*logout.*'
)

zap.ascan.set_option_thread_per_host(5)
zap.ascan.set_option_max_scan_duration_in_mins(30)

zap.core.save_session('my_session')
# 나중에...
zap.core.load_session('my_session')

🐛 문제 해결 가이드

ZAP 자동화하다 보면 여러 문제를 만날 수 있어. 자주 발생하는 문제들과 해결 방법을 정리해봤어! 🔧

문제 1: ZAP API 연결 실패

# ZAP이 실행 중인지 확인
ps aux | grep zap

# 포트 확인
netstat -an | grep 8080

# ZAP 재시작
zap.sh -daemon -host 0.0.0.0 -port 8080

문제 2: 스캔이 멈춤

# 타임아웃 설정
zap.ascan.set_option_max_scan_duration_in_mins(60)

# 강제 중지 후 재시작
zap.ascan.stop(scan_id)
time.sleep(5)
scan_id = zap.ascan.scan(target_url)

문제 3: 메모리 부족

# ZAP 실행 시 메모리 할당
zap.sh -daemon -Xmx4g  # 4GB 할당

# 또는 Docker 사용 시
docker run -m 4g owasp/zap2docker-stable

문제 4: 인증 실패

# 인증 검증 URL 설정
zap.authentication.set_logged_in_indicator(
    contextid=context_id,
    loggedinindicatorregex='Logout'
)

# 세션 유지 확인
zap.httpsessions.set_active_session(
    site=target_url,
    session='session_name'
)

🌟 베스트 프랙티스

실무에서 ZAP 자동화를 성공적으로 운영하기 위한 베스트 프랙티스를 공유할게! 이건 정말 중요한 내용이니까 꼭 기억해둬. 📚

# config/dev.env
ZAP_ATTACK_STRENGTH=HIGH
ZAP_SCAN_POLICY=full

# config/prod.env
ZAP_ATTACK_STRENGTH=LOW
ZAP_SCAN_POLICY=passive_only

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('zap_automation.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)
logger.info("ZAP 스캔 시작")

# false_positives.json
{
  "excluded_alerts": [
    {
      "alert": "X-Frame-Options Header Not Set",
      "url": "https://example.com/public/*",
      "reason": "Public pages don't need frame protection"
    }
  ]
}

# 자동 업데이트 스크립트
def update_zap():
    print("🔄 ZAP 업데이트 확인 중...")
    zap.autoupdate.download_latest_release()
    print("✅ 업데이트 완료!")

🎓 실전 프로젝트: 완전한 자동화 시스템 구축

지금까지 배운 모든 걸 종합해서 실제로 사용할 수 있는 완전한 자동화 시스템을 만들어보자! 이건 진짜 실무에서 바로 쓸 수 있는 수준이야. 🚀

프로젝트 구조

zap-automation/
├── config/
│   ├── dev.env
│   ├── staging.env
│   └── prod.env
├── scripts/
│   ├── zap_scanner.py
│   ├── report_generator.py
│   └── notification.py
├── policies/
│   ├── full_scan.policy
│   └── quick_scan.policy
├── reports/
│   └── (generated reports)
├── logs/
│   └── (log files)
├── docker-compose.yml
├── requirements.txt
└── README.md

메인 스캐너 모듈 (zap_scanner.py)

#!/usr/bin/env python3
"""
ZAP 자동화 스캐너 - 메인 모듈
"""

import os
import sys
import time
import logging
from datetime import datetime
from zapv2 import ZAPv2
from dotenv import load_dotenv
import argparse

class ZAPScanner:
    """ZAP 스캐너 클래스"""
    
    def __init__(self, config_file=None):
        """초기화"""
        if config_file:
            load_dotenv(config_file)
        else:
            load_dotenv()
        
        self.zap = ZAPv2(
            apikey=os.getenv('ZAP_API_KEY'),
            proxies={
                'http': f"http://{os.getenv('ZAP_HOST')}:{os.getenv('ZAP_PORT')}",
                'https': f"http://{os.getenv('ZAP_HOST')}:{os.getenv('ZAP_PORT')}"
            }
        )
        
        self.target_url = os.getenv('TARGET_URL')
        self.scan_policy = os.getenv('SCAN_POLICY', 'default')
        
        # 로깅 설정
        self.setup_logging()
        
    def setup_logging(self):
        """로깅 설정"""
        log_dir = 'logs'
        os.makedirs(log_dir, exist_ok=True)
        
        log_file = os.path.join(
            log_dir,
            f"zap_scan_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
        )
        
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler(log_file),
                logging.StreamHandler(sys.stdout)
            ]
        )
        
        self.logger = logging.getLogger(__name__)
        self.logger.info("ZAP Scanner 초기화 완료")
    
    def check_zap_connection(self):
        """ZAP 연결 확인"""
        try:
            version = self.zap.core.version
            self.logger.info(f"ZAP 연결 성공 (버전: {version})")
            return True
        except Exception as e:
            self.logger.error(f"ZAP 연결 실패: {e}")
            return False
    
    def setup_context(self, context_name="AutoScanContext"):
        """컨텍스트 설정"""
        self.logger.info(f"컨텍스트 '{context_name}' 설정 중...")
        
        # 새 컨텍스트 생성
        context_id = self.zap.context.new_context(context_name)
        
        # URL 포함
        self.zap.context.include_in_context(
            context_name,
            f"{self.target_url}.*"
        )
        
        # 제외할 URL 패턴
        exclude_patterns = [
            '.*logout.*',
            '.*signout.*',
            '.*delete.*'
        ]
        
        for pattern in exclude_patterns:
            self.zap.context.exclude_from_context(context_name, pattern)
        
        self.logger.info(f"컨텍스트 설정 완료 (ID: {context_id})")
        return context_id
    
    def run_spider(self):
        """Spider 크롤링 실행"""
        self.logger.info("Spider 크롤링 시작...")
        
        scan_id = self.zap.spider.scan(self.target_url)
        
        while int(self.zap.spider.status(scan_id)) < 100:
            progress = self.zap.spider.status(scan_id)
            self.logger.info(f"Spider 진행률: {progress}%")
            time.sleep(3)
        
        urls_found = len(self.zap.spider.results(scan_id))
        self.logger.info(f"Spider 완료 - {urls_found}개 URL 발견")
        
        return urls_found
    
    def run_ajax_spider(self):
        """Ajax Spider 실행"""
        self.logger.info("Ajax Spider 시작...")
        
        self.zap.ajaxSpider.set_option_max_duration('5')
        self.zap.ajaxSpider.scan(self.target_url)
        
        while self.zap.ajaxSpider.status == 'running':
            results = self.zap.ajaxSpider.number_of_results
            self.logger.info(f"Ajax Spider 실행 중... ({results}개 URL)")
            time.sleep(5)
        
        urls_found = self.zap.ajaxSpider.number_of_results
        self.logger.info(f"Ajax Spider 완료 - {urls_found}개 URL 발견")
        
        return urls_found
    
    def wait_passive_scan(self):
        """Passive Scan 완료 대기"""
        self.logger.info("Passive Scan 대기 중...")
        
        while int(self.zap.pscan.records_to_scan) > 0:
            records = self.zap.pscan.records_to_scan
            self.logger.info(f"Passive Scan 남은 레코드: {records}")
            time.sleep(2)
        
        self.logger.info("Passive Scan 완료")
    
    def run_active_scan(self):
        """Active Scan 실행"""
        self.logger.info("Active Scan 시작...")
        
        scan_id = self.zap.ascan.scan(self.target_url)
        
        while int(self.zap.ascan.status(scan_id)) < 100:
            progress = self.zap.ascan.status(scan_id)
            self.logger.info(f"Active Scan 진행률: {progress}%")
            time.sleep(10)
        
        self.logger.info("Active Scan 완료")
        return scan_id
    
    def get_alerts(self):
        """알림 수집"""
        self.logger.info("스캔 결과 수집 중...")
        
        alerts = self.zap.core.alerts(baseurl=self.target_url)
        
        # 심각도별 분류
        severity_counts = {
            'High': 0,
            'Medium': 0,
            'Low': 0,
            'Informational': 0
        }
        
        for alert in alerts:
            severity_counts[alert['risk']] += 1
        
        self.logger.info("스캔 결과 요약:")
        for severity, count in severity_counts.items():
            self.logger.info(f"  {severity}: {count}개")
        
        return alerts, severity_counts
    
    def generate_report(self, alerts):
        """리포트 생성"""
        self.logger.info("리포트 생성 중...")
        
        report_dir = 'reports'
        os.makedirs(report_dir, exist_ok=True)
        
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        
        # HTML 리포트
        html_report = self.zap.core.htmlreport()
        html_file = os.path.join(report_dir, f"zap_report_{timestamp}.html")
        with open(html_file, 'w', encoding='utf-8') as f:
            f.write(html_report)
        
        self.logger.info(f"HTML 리포트 생성: {html_file}")
        
        # JSON 리포트
        import json
        json_file = os.path.join(report_dir, f"zap_report_{timestamp}.json")
        with open(json_file, 'w', encoding='utf-8') as f:
            json.dump(alerts, f, indent=2, ensure_ascii=False)
        
        self.logger.info(f"JSON 리포트 생성: {json_file}")
        
        return html_file, json_file
    
    def run_full_scan(self):
        """전체 스캔 실행"""
        self.logger.info("="*60)
        self.logger.info("ZAP 전체 스캔 시작")
        self.logger.info(f"대상 URL: {self.target_url}")
        self.logger.info("="*60)
        
        start_time = time.time()
        
        try:
            # 1. ZAP 연결 확인
            if not self.check_zap_connection():
                raise Exception("ZAP 연결 실패")
            
            # 2. 새 세션 시작
            self.zap.core.new_session()
            
            # 3. 컨텍스트 설정
            context_id = self.setup_context()
            
            # 4. Spider 실행
            spider_urls = self.run_spider()
            
            # 5. Ajax Spider 실행 (옵션)
            if os.getenv('USE_AJAX_SPIDER', 'false').lower() == 'true':
                ajax_urls = self.run_ajax_spider()
            
            # 6. Passive Scan 대기
            self.wait_passive_scan()
            
            # 7. Active Scan 실행
            scan_id = self.run_active_scan()
            
            # 8. 결과 수집
            alerts, severity_counts = self.get_alerts()
            
            # 9. 리포트 생성
            html_file, json_file = self.generate_report(alerts)
            
            # 10. 실행 시간 계산
            elapsed_time = time.time() - start_time
            
            self.logger.info("="*60)
            self.logger.info("스캔 완료!")
            self.logger.info(f"총 실행 시간: {elapsed_time:.2f}초")
            self.logger.info(f"발견된 이슈: {len(alerts)}개")
            self.logger.info("="*60)
            
            return {
                'success': True,
                'alerts': alerts,
                'severity_counts': severity_counts,
                'reports': {
                    'html': html_file,
                    'json': json_file
                },
                'elapsed_time': elapsed_time
            }
            
        except Exception as e:
            self.logger.error(f"스캔 중 오류 발생: {e}")
            return {
                'success': False,
                'error': str(e)
            }

def main():
    """메인 함수"""
    parser = argparse.ArgumentParser(description='ZAP 자동화 스캐너')
    parser.add_argument(
        '--config',
        help='설정 파일 경로',
        default=None
    )
    parser.add_argument(
        '--target',
        help='대상 URL',
        default=None
    )
    
    args = parser.parse_args()
    
    # 스캐너 초기화
    scanner = ZAPScanner(config_file=args.config)
    
    # 대상 URL 오버라이드
    if args.target:
        scanner.target_url = args.target
    
    # 스캔 실행
    result = scanner.run_full_scan()
    
    # 결과에 따라 종료 코드 반환
    sys.exit(0 if result['success'] else 1)

if __name__ == "__main__":
    main()

Docker Compose 설정

Docker를 사용하면 환경 설정이 훨씬 쉬워져! 🐳

version: '3.8'

services:
  zap:
    image: owasp/zap2docker-stable
    container_name: zap-daemon
    ports:
      - "8080:8080"
    command: zap.sh -daemon -host 0.0.0.0 -port 8080 -config api.disablekey=true
    volumes:
      - ./reports:/zap/wrk
    networks:
      - zap-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080"]
      interval: 30s
      timeout: 10s
      retries: 3
  
  scanner:
    build: .
    container_name: zap-scanner
    depends_on:
      - zap
    environment:
      - ZAP_HOST=zap
      - ZAP_PORT=8080
      - TARGET_URL=${TARGET_URL}
    volumes:
      - ./reports:/app/reports
      - ./logs:/app/logs
    networks:
      - zap-network
    command: python zap_scanner.py

networks:
  zap-network:
    driver: bridge

🌐 재능넷에서 보안 전문가 찾기

ZAP 자동화를 배우는 건 좋지만, 때로는 전문가의 도움이 필요할 때가 있어. 재능넷에서는 보안 테스팅, 자동화 스크립팅, DevSecOps 구축 등 다양한 보안 관련 재능을 가진 전문가들을 만날 수 있어! 💼

특히 처음 보안 자동화 시스템을 구축할 때는 경험 있는 전문가의 컨설팅을 받으면 시행착오를 많이 줄일 수 있거든. 재능넷에서 보안 전문가를 찾아보는 것도 좋은 방법이야! 🎯

📚 추가 학습 리소스

ZAP 자동화를 더 깊이 공부하고 싶다면 이런 리소스들을 참고해봐! 📖

🎯 마무리하며

와! 여기까지 읽었다면 정말 대단해! 🎉 우리는 OWASP ZAP 자동화 스크립팅의 기초부터 고급 기법, 실전 프로젝트까지 정말 많은 걸 다뤘어.

보안 자동화는 한 번 설정해두면 계속해서 가치를 제공하는 투자야. 처음에는 설정하는 데 시간이 걸리지만, 일단 구축하고 나면 반복적인 보안 테스트를 자동으로 수행할 수 있어서 엄청난 시간을 절약할 수 있지. ⏰

보안은 한 번 하고 끝나는 게 아니라 지속적으로 관리해야 하는 프로세스야. ZAP 자동화는 이런 지속적인 보안 관리를 효율적으로 만들어주는 강력한 도구지. 💪

이 글이 여러분의 보안 자동화 여정에 도움이 되었으면 좋겠어. 궁금한 점이 있거나 더 알고 싶은 내용이 있다면 언제든지 커뮤니티에 질문해봐. 우리 모두 함께 더 안전한 웹을 만들어가자! 🌟

해피 해킹! (물론 화이트햇으로! 😄) 🛡️