DAST - Dynamic Application Security Testing

DAST vs. SAST - Klíčové rozdíly

Vlastnost	DAST (Dynamic)	SAST (Static)
Kdy testuje	Runtime - aplikace musí běžet	Build time - statická analýza kódu
Přístup ke kódu	Black-box - nepotřebuje zdrojový kód	White-box - vyžaduje přístup ke kódu
Co detekuje	Runtime zranitelnosti, konfigurace, deployment issues	Coding errors, unsafe patterns, potenciální zranitelnosti
False positives	Nízké - testuje skutečné chování	Vyšší - může označit bezpečný kód
Rychlost	Pomalejší (hodiny pro velké aplikace)	Rychlejší (minuty)
Typ zranitelností	SQL injection, XSS, CSRF, auth issues, SSRF	Buffer overflows, race conditions, unsafe functions
Jazyk	Language-agnostic (testuje HTTP API)	Specifické pro jazyk (Java, C#, Python...)
Fáze SDLC	QA, Staging, Pre-production	Development, PR reviews

Best Practice: Kombinujte SAST + DAST

Nejlepší výsledky dosáhnete kombinací obou přístupů. SAST odhalí potenciální problémy v kódu během vývoje, zatímco DAST ověří, zda jsou tyto zranitelnosti exploitovatelné v reálném prostředí. Tato strategie se nazývá "Defense in Depth" a pokrývá jak teoretické, tak praktické bezpečnostní mezery.

Jak DAST funguje

Typický DAST scan workflow

1

Crawling (Spider) Scanner prochází aplikaci jako běžný uživatel, mapuje všechny stránky, formuláře, parametry a endpointy

2

Attack Surface Mapping Identifikuje vstupní body (input fields, URL params, headers, cookies) kde může provést testy

3

Fuzzing & Injection Posílá škodlivé payloady (SQL injection, XSS, command injection) do všech vstupních bodů

4

Response Analysis Analyzuje HTTP odpovědi, chybové hlášky, timing patterns pro detekci zranitelností

5

Vulnerability Confirmation Ověřuje false positives a generuje detailní report s PoC (Proof of Concept)

6

Reporting Vytvoří prioritizovaný seznam zranitelností s CVSS scores, remediation steps a reprodukčními kroky

Co DAST detekuje

1. Injection útoky

SQL Injection: Manipulace s databázovými dotazy přes user input
Command Injection: Spuštění OS příkazů přes nezabezpečený input
LDAP/XML/XPath Injection: Injection do specifických dotazovacích jazyků
Template Injection: SSTI (Server-Side Template Injection)

2. Cross-Site Scripting (XSS)

Reflected XSS: Škodlivý script v URL/parametru odražený zpět uživateli
Stored XSS: Persistentní XSS uložený v databázi
DOM-based XSS: Client-side XSS přes JavaScript manipulaci

3. Autentizace a Session Management

Broken Authentication: Slabé hesla, session hijacking, credential stuffing
Session Fixation: Útočník fixuje session ID oběti
Insecure Session Cookies: Chybějící Secure/HttpOnly/SameSite flags
JWT vulnerabilities: Weak signing, algorithm confusion

4. Broken Access Control

IDOR (Insecure Direct Object References): Přístup k cizím objektům změnou ID
Path Traversal: Přístup k souborům mimo webroot (../../../etc/passwd)
Privilege Escalation: Běžný uživatel získá admin práva
Missing Function Level Access Control: API endpointy bez autorizace

5. Security Misconfiguration

Verbose Error Messages: Stack traces odhalující interní informace
Default Credentials: Admin/admin, root/root
Directory Listing: Viditelné adresářové struktury
Missing Security Headers: CSP, HSTS, X-Frame-Options
Exposed Admin Panels: /admin, /phpmyadmin, /wp-admin bez ochrany

6. Další runtime zranitelnosti

CSRF (Cross-Site Request Forgery): Neoprávněné akce jménem uživatele
SSRF (Server-Side Request Forgery): Server provede request na útočníkem zvolený target
XXE (XML External Entity): Čtení souborů přes XML parser
Insecure Deserialization: RCE přes deserializaci untrusted dat
Business Logic Flaws: Race conditions, price manipulation

Oblíbené DAST nástroje

Open Source / Free

OWASP ZAP (Zed Attack Proxy)

Nejpopulárnější open-source DAST nástroj. Ideální pro začátečníky i profesionály, s GUI i CLI režimem.

Aktivní i pasivní skanování
Intercepting proxy pro manuální testování
Spidering a automatický crawling
API scan (REST, GraphQL, SOAP)
CI/CD integrace (Docker, Jenkins, GitLab)
1000+ security checks

Commercial / Freemium

Burp Suite Professional

Industry-standard penetration testing platforma s pokročilými funkcemi pro manuální i automatické testování.

Burp Scanner - automatický vulnerability scanner
Intruder - advanced fuzzing engine
Repeater - request manipulation
Collaborator - out-of-band detection (SSRF, XXE)
Extensions (BApp Store)
$449/rok pro Professional license

Open Source

Nuclei

Moderní fast vulnerability scanner založený na YAML templates. Ideální pro CI/CD automatizaci.

4000+ community templates
Rychlé paralelní skanování
Custom templates v YAML
Integration s Slack, Jira, GitHub
Headless browser support

Commercial SaaS

Acunetix

Enterprise-grade web vulnerability scanner se zaměřením na komplexní JavaScript aplikace.

Advanced JavaScript/SPA crawling
Network security scanning
Integration s WAF (Web Application Firewall)
Issue tracking (Jira, GitHub)

Open Source

Nikto

Klasický web server scanner pro detekci známých zranitelností a misconfigurations.

7000+ potentially dangerous files/programs
Outdated server versions detection
Server misconfigurations
Fast, lightweight CLI tool

Cloud / API-focused

StackHawk

Moderní DAST platforma zaměřená na API security a developer-first workflow.

OpenAPI/Swagger integration
GraphQL endpoint testing
CI/CD native (GitHub Actions, GitLab CI)
Developer-friendly reporting
Shift-left DAST approach

Praktický příklad: OWASP ZAP v CI/CD

Integrace OWASP ZAP do GitLab CI/CD pipeline:

# .gitlab-ci.yml
stages:
  - build
  - test
  - security
  - deploy

# DAST scan using OWASP ZAP
dast_scan:
  stage: security
  image: owasp/zap2docker-stable
  variables:
    TARGET_URL: "https://staging.example.com"
  script:
    # Baseline scan (passive + spider)
    - zap-baseline.py -t $TARGET_URL -r zap-report.html -J zap-report.json

    # Full scan (active attacks) - můžete použít pro staging
    # - zap-full-scan.py -t $TARGET_URL -r zap-report.html -J zap-report.json

    # API scan s OpenAPI spec
    # - zap-api-scan.py -t $TARGET_URL -f openapi -r api-report.html
  artifacts:
    reports:
      # GitLab Security Dashboard integration
      sast: zap-report.json
    paths:
      - zap-report.html
    expire_in: 1 week
  allow_failure: false  # Zablokovat deployment pokud critical issues
  only:
    - merge_requests
    - main
                    

GitHub Actions příklad

name: DAST Scan

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

jobs:
  zap_scan:
    runs-on: ubuntu-latest
    name: OWASP ZAP Scan
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Deploy to staging
        run: |
          # Deploy aplikace do staging pro testing
          docker-compose up -d
          sleep 30  # Počkat na start aplikace

      - name: ZAP Baseline Scan
        uses: zaproxy/action-baseline@v0.7.0
        with:
          target: 'http://localhost:3000'
          rules_file_name: '.zap/rules.tsv'
          cmd_options: '-a'

      - name: Upload ZAP Report
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: zap-scan-report
          path: report_html.html

      - name: Fail build on high severity
        run: |
          # Parse JSON report a fail pokud critical/high
          HIGH_COUNT=$(jq '.site[0].alerts | map(select(.riskcode >= 2)) | length' report_json.json)
          if [ "$HIGH_COUNT" -gt 0 ]; then
            echo "Found $HIGH_COUNT high/critical vulnerabilities!"
            exit 1
          fi
                    

Docker Compose pro lokální DAST testing

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      NODE_ENV: test
      DATABASE_URL: postgres://user:pass@db:5432/testdb

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: testdb

  zap:
    image: owasp/zap2docker-stable
    command: zap-baseline.py -t http://app:3000 -r /zap/wrk/report.html
    volumes:
      - ./zap-reports:/zap/wrk
    depends_on:
      - app

# Použití:
# docker-compose up -d app db
# docker-compose run zap
# Report bude v ./zap-reports/report.html
                    

DAST Best Practices

Doporučené postupy

Testujte na staging/QA, ne na production: DAST může způsobit DOS, data corruption nebo triggernout alarmy
Používejte test credentials: Dedicated test účty pro authenticated scanning
Rate limiting awareness: DAST generuje mnoho requestů, můžete být zablokováni WAF/CDN
Baseline vs Full scan: Baseline pro každý PR, Full scan weekly/před releasem
Custom scan policies: Vypněte testy, které nejsou relevantní (např. CMS scan pro API-only app)
Authentication context: Konfigurujte ZAP/Burp pro login workflow, testujte authenticated areas
API specification: Používejte OpenAPI/Swagger specs pro lepší coverage API endpointů
False positive management: Reviewujte a markujte FP, vytvářejte whitelisty
Trend tracking: Sledujte počet zranitelností v čase, ne jen current state
Integration se SIEM: Posílejte DAST findings do centrálního security dashboardu

Časté chyby při DAST

Spuštění DAST na production: Může způsobit outage, corrupt data nebo false alarms
Nedostatečný crawling scope: Scanner nenajde všechny endpointy (zejména u SPA)
Ignorování false positives: Teams ztratí důvěru v nástroj
Pouze automatické scany: Manuální pentesting najde business logic flaws, které DAST neodhalí
Žádný authentication: 80% aplikace je za loginem, skenování homepage je nedostatečné
Jeden scan = hotovo: DAST by měl běžet continuously, ne jen před releasem
Neaktualizované scanery: Nové CVE a attack vectors vyžadují fresh vulnerability checks

DAST pro různé typy aplikací

1. REST API

# OWASP ZAP API scan s OpenAPI spec
zap-api-scan.py \
  -t https://api.example.com/v1 \
  -f openapi \
  -d api-spec.yaml \
  -r api-security-report.html \
  -J api-report.json \
  -x api-xml-report.xml

# Postman Collection import do ZAP
# 1. Export Postman collection
# 2. Import do ZAP jako "context"
# 3. Run Active Scan na importované endpointy
                    

2. GraphQL API

# Escape GraphQL Security Scanner
npm install -g @escape.tech/graphql-armor

# Introspection query pro mapování schema
curl -X POST https://api.example.com/graphql \
  -H "Content-Type: application/json" \
  -d '{"query": "{__schema{types{name fields{name}}}}"}'

# ZAP GraphQL plugin
# Automaticky detekuje GraphQL endpointy a testuje:
# - Depth limit bypass
# - Batching attacks
# - Introspection exposure
# - Mutation authorization
                    

3. Single Page Applications (SPA)

# ZAP s headless browser pro React/Vue/Angular apps
zap.sh -daemon -config api.disablekey=true -config spider.maxDuration=60

# Použití Ajax Spider místo tradičního spider
# Ajax Spider používá Selenium pro JavaScript rendering
curl -X POST \
  'http://localhost:8080/JSON/ajaxSpider/action/scan/?url=https://app.example.com'

# Nebo Nuclei s headless mode
nuclei -u https://app.example.com \
  -headless \
  -t ~/nuclei-templates/ \
  -o spa-scan-results.txt
                    

DAST vs IAST vs RASP

Nástroj	Jak funguje	Výhody	Nevýhody
DAST (Dynamic)	Black-box testování běžící aplikace z venku	Žádný přístup ke kódu, language-agnostic, nízké false positives	Pomalé, nedává přesnou lokaci v kódu, potřebuje běžící aplikaci
SAST (Static)	Analýza zdrojového kódu bez spuštění	Rychlé, early detection, přesná lokace v kódu	Vyšší false positives, language-specific, nevidí runtime issues
IAST (Interactive)	Agent uvnitř aplikace monitorující runtime behavior	Přesné, nízké FP, code-level insights + runtime context	Vyžaduje instrumentation, performance overhead
RASP (Runtime Protection)	Active defense v production - blokuje útoky real-time	Production security, zero-day protection, virtual patching	Performance impact, false positive může blokovat legitimate users