# Instalar aplicaciones vulnerables para el lab
sudo apt install docker.io docker-compose -y

# DVWA (Damn Vulnerable Web Application)
docker run -d -p 8080:80 --name dvwa vulnerables/web-dvwa

# Juice Shop (OWASP)
docker run -d -p 3000:3000 --name juiceshop bkimminich/juice-shop

# WebGoat
docker run -d -p 8088:8080 --name webgoat webgoat/goatandwolf

# Verificar que están corriendo
docker ps
CONTAINER ID   IMAGE                     PORTS                    NAMES
a1b2c3d4       vulnerables/web-dvwa      0.0.0.0:8080->80/tcp     dvwa
e5f6a7b8       bkimminich/juice-shop     0.0.0.0:3000->3000/tcp   juiceshop
c9d0e1f2       webgoat/goatandwolf       0.0.0.0:8088->8080/tcp   webgoat

wapiti -u URL [opciones]

## TARGET
-u URL              → URL de inicio del crawling
--scope URL|domain  → alcance del crawling (URL exacta o todo el dominio)

## MÓDULOS
-m sql,xss,blindsql → ejecutar solo estos módulos
--list-modules       → listar todos los módulos disponibles
--skip-crawl         → no crawlear, usar solo la URL dada

## AUTENTICACIÓN
--auth-user USER     → usuario para login form
--auth-password PASS → contraseña para login form
--auth-method post  → método de autenticación
-c cookies.pkl       → usar cookies guardadas

## OUTPUT
-f html              → formato del informe: html, json, xml, txt
-o /tmp/report       → directorio de salida del informe
--color              → output con colores en terminal

## RENDIMIENTO
--max-depth N        → profundidad máxima de crawling
--max-links-per-page N → max links por página
--max-scan-time N    → tiempo máximo de escaneo en segundos
-t N                 → timeout por petición (segundos)

# Escaneo completo con todos los módulos + informe HTML
wapiti -u http://target.com --scope domain -f html -o /tmp/report --color

# Solo SQLi y XSS (más rápido)
wapiti -u http://target.com -m sql,xss,blindsql -f json -o /tmp/report

# Con autenticación en formulario de login
wapiti -u http://target.com --auth-user admin --auth-password password \
  --auth-method post --auth-url http://target.com/login -f html -o /tmp/r

# Con cookies (sesión ya autenticada)
wapiti -u http://target.com -c /tmp/cookies.pkl --color -f html -o /tmp/r

# Limitar tiempo de escaneo (útil en CI/CD)
wapiti -u http://target.com --max-scan-time 1800 -f json -o /tmp/r

# Escaneo de API OpenAPI/Swagger
wapiti -u http://api.target.com --swagger http://api.target.com/swagger.json -f json -o /tmp/r

# Con proxy (para ver tráfico en Burp Suite)
wapiti -u http://target.com --proxy http://127.0.0.1:8080 -f html -o /tmp/r

wapiti --list-modules

Módulos Web (inyección de payloads):
  sql         → SQL Injection (error-based)
  blindsql    → Blind SQL Injection (time-based)
  xss         → Cross-Site Scripting (reflejado y almacenado)
  ssti        → Server-Side Template Injection
  ssrf        → Server-Side Request Forgery
  redirect    → Open Redirect
  crlf        → CRLF Injection (HTTP header injection)
  xxe         → XML External Entity Injection
  exec        → Command Execution / OS Injection
  shellshock  → Shellshock (CVE-2014-6271)
  file        → File Disclosure (LFI/Path Traversal)
  cms         → CMS Detection (WordPress, Joomla, Drupal)

Módulos de Información:
  backup      → Archivos de backup expuestos (.bak, .old, ~)
  brute_login → Fuerza bruta en formularios de login
  csrf        → Cross-Site Request Forgery
  cookieflags → Flags de seguridad en cookies
  headers     → Cabeceras HTTP de seguridad ausentes
  http_headers → Información en cabeceras HTTP
  htaccess    → Archivos .htaccess accesibles
  methods     → Métodos HTTP permitidos (PUT, DELETE...)
  wapp        → Detección de tecnologías (Wappalyzer)
  timesql     → SQL injection por tiempo de respuesta

# Solo módulos SQLi (error + blind time-based)
wapiti -u http://localhost:8080/dvwa/ -m sql,blindsql --color -f html -o /tmp/sqli_report

# Con autenticación para acceder a áreas protegidas
wapiti -u http://localhost:8080/dvwa/ \
  --auth-user admin --auth-password password \
  --auth-method post \
  --auth-url http://localhost:8080/dvwa/login.php \
  -m sql,blindsql --color -f html -o /tmp/sqli_auth_report

# Forzar escaneo de URL específica sin crawling
wapiti -u "http://localhost:8080/dvwa/vulnerabilities/sqli/?id=1&Submit=Submit" \
  --scope url -m sql,blindsql --color

# Error-based (detecta mensajes de error SQL en la respuesta)
1'
1''
' OR '1'='1
1' AND 1=CONVERT(int,@@version)--
' UNION SELECT NULL,NULL,NULL--

# Boolean-based (compara respuesta con/sin condición)
1 AND 1=1  # → misma respuesta que sin payload
1 AND 1=2  # → respuesta diferente → SQLi boolean

# Time-based blind (detecta por diferencia de tiempo)
1 AND SLEEP(5)           # MySQL
1; WAITFOR DELAY '0:0:5' # MSSQL
1 AND pg_sleep(5)        # PostgreSQL
1 AND RANDOMBLOB(100000000) # SQLite

# Módulo XSS sobre DVWA
wapiti -u http://localhost:8080/dvwa/ -m xss \
  --auth-user admin --auth-password password \
  --auth-method post --auth-url http://localhost:8080/dvwa/login.php \
  --color -f html -o /tmp/xss_report

# Wapiti también detecta Stored XSS (persiste en la BD)
# El spider lo detecta al releer páginas después de inyectar

# Módulo file (LFI, path traversal, file disclosure)
wapiti -u http://localhost:8080/dvwa/ -m file,ssrf \
  --auth-user admin --auth-password password \
  --auth-method post --auth-url http://localhost:8080/dvwa/login.php \
  --color -f html -o /tmp/lfi_report

# HTML (para presentar)
wapiti -u http://target.com -f html -o /tmp/report_html
firefox /tmp/report_html/index.html

# JSON (para pipelines)
wapiti -u http://target.com -f json -o /tmp/report.json
cat /tmp/report.json | python3 -m json.tool | head -50

# Parsear el JSON de Wapiti
python3 -c "
import json
report = json.load(open('/tmp/report.json'))
vulns = report.get('vulnerabilities', {})
for vuln_type, findings in vulns.items():
    for f in findings:
        print(f'[{vuln_type.upper()}] {f[\"path\"]} - Param: {f.get(\"parameter\",\"N/A\")}')
"
[SQL_INJECTION] /dvwa/sqli/ - Param: id
[XSS] /dvwa/xss_r/ - Param: name
[FILE_HANDLING] /dvwa/fi/ - Param: page

# XML (para importar en herramientas como DefectDojo)
wapiti -u http://target.com -f xml -o /tmp/report.xml

nikto -h TARGET [opciones]

## TARGET
-h HOST         → host o URL objetivo
-p PORT         → puerto (default: 80)
-ssl            → forzar HTTPS

## TUNING (qué categorías escanear)
-Tuning 1       → Interesting File / Seen in logs
-Tuning 2       → Misconfiguration / Default File
-Tuning 3       → Information Disclosure
-Tuning 4       → Injection (XSS/Script/HTML)
-Tuning 6       → Denial of Service
-Tuning 9       → SQL Injection
-Tuning x       → Reverse Tuning (excluir categoría)

## OUTPUT
-o FILE.html    → guardar informe (detecta formato por extensión)
-Format html   → forzar formato: html, csv, txt, json, xml

## OPCIONES
-C all          → escanear todos los CGI dirs
-useragent UA   → User-Agent personalizado
-timeout N      → timeout por petición
-maxtime Ns     → tiempo máximo total de escaneo
-Plugins LISTA  → plugins específicos a usar

# Escaneo HTTPS
nikto -h https://target.com -ssl -o /tmp/nikto_ssl.html

# Solo misconfigs y archivos interesantes (rápido)
nikto -h http://target.com -Tuning 1,2,3 -o /tmp/nikto_fast.html

# Con autenticación HTTP Basic
nikto -h http://target.com -id admin:password -o /tmp/nikto_auth.html

# Con cookies (sesión autenticada)
nikto -h http://target.com -Cookies "PHPSESSID=abc123; security=low" -o /tmp/nikto_session.html

# Via proxy (para ver en Burp Suite)
nikto -h http://target.com -useproxy http://127.0.0.1:8080 -o /tmp/nikto_proxy.html

# Escaneo masivo de múltiples hosts
nikto -h hosts.txt -o /tmp/nikto_mass.csv -Format csv

# Tiempo máximo 5 minutos (CI/CD)
nikto -h http://target.com -maxtime 300s -o /tmp/nikto_quick.html

# Evasión básica de IDS — modo de evasión 1 (aleatorizar mayúsculas URL)
nikto -h http://target.com -evasion 1 -o /tmp/nikto_evade.html

# Ver todos los plugins disponibles
nikto -list-plugins

# Formato de cada hallazgo de Nikto:
+ /phpinfo.php: Output from the phpinfo() function was found.
  ^                ^
  |                Descripción del hallazgo
  Ruta encontrada

  OSVDB-ID: 12184
  ^
  Base de datos de vulnerabilidades (Open Source Vulnerability Database)

# Clasificación por prefijo del mensaje:
+ Server: Apache/2.4.38    → información del servidor (sin + de peligro)
+ X-Frame-Options...       → cabecera de seguridad ausente (bajo riesgo)
+ /admin/ accessible       → directorio/archivo expuesto (medio riesgo)
+ Default password found   → credencial por defecto (alto riesgo)
+ CVE-XXXX-XXXX found      → CVE documentado (crítico)

# Parsear output JSON de Nikto
nikto -h http://target.com -Format json -o /tmp/nikto.json
cat /tmp/nikto.json | python3 -c "
import json,sys
data=json.load(sys.stdin)
for vuln in data.get('vulnerabilities',[]):
    sev = 'HIGH' if 'CVE' in str(vuln) else 'LOW'
    print(f'[{sev}] {vuln[\"url\"]} — {vuln[\"msg\"][:80]}')
"

# Levantar DVWA
docker run -d -p 8080:80 --name dvwa vulnerables/web-dvwa
# Visitar http://localhost:8080, login admin/password
# Ir a Setup/Reset DB → Create/Reset Database
# Security Level → Low (para que Wapiti detecte todo)

# Terminal 1: Wapiti
wapiti -u http://localhost:8080/dvwa/ \
  --auth-user admin --auth-password password \
  --auth-method post --auth-url http://localhost:8080/dvwa/login.php \
  -m sql,xss,exec,file,csrf \
  -f html -o /tmp/wapiti_report 2>&1 | tee /tmp/wapiti.log &

# Terminal 2: Nikto (corre mucho más rápido)
nikto -h http://localhost:8080 -p 8080 \
  -Cookies "PHPSESSID=$(curl -s -c /tmp/cookies.txt -d 'username=admin&password=password&Login=Login' http://localhost:8080/dvwa/login.php > /dev/null && grep PHPSESSID /tmp/cookies.txt | awk '{print $NF}')" \
  -C all -o /tmp/nikto_report.html 2>&1 | tee /tmp/nikto.log &

# Esperar a que terminen
wait && echo "Ambos escaneos completados"

# Comparar hallazgos
echo "=== WAPITI ===" && grep "!" /tmp/wapiti.log | wc -l
echo "=== NIKTO ===" && grep "^+" /tmp/nikto.log | wc -l

# Levantar WordPress vulnerable para el lab
docker run -d -p 8081:80 --name wpvuln \
  -e WORDPRESS_DB_HOST=db \
  wordpress:5.8-php7.4-apache

## NIKTO — Excelente para WP: detecta versión, rutas expuestas, plugins
nikto -h http://localhost:8081 -C all \
  -Plugins "@@ALL" \
  -o /tmp/wp_nikto.html
+ WordPress version 5.8 found
+ /wp-admin/ accessible (admin panel)
+ /wp-login.php accessible
+ /readme.html reveals WordPress version
+ /xmlrpc.php accessible (bruteforce vector)
+ /wp-content/debug.log accessible (info disclosure)

## WAPITI — Fuzzing en formularios WP
wapiti -u http://localhost:8081 \
  --scope domain \
  -m xss,sql,exec,backup,redirect,cookieflags,headers,cms \
  -f html -o /tmp/wp_wapiti_report
[*] CMS detected: WordPress 5.8
[!] XSS in search parameter
[!] Backup file found: /wp-config.php.bak
[!] Cookie without Secure flag: wordpress_test_cookie

# Wapiti con autenticación WP (si tenemos credenciales)
wapiti -u http://localhost:8081/wp-admin/ \
  --auth-user admin --auth-password password \
  --auth-method post \
  --auth-url http://localhost:8081/wp-login.php \
  -m sql,xss,exec,file --color -f html -o /tmp/wp_auth_report

# Juice Shop expone Swagger en /api-docs
docker run -d -p 3000:3000 bkimminich/juice-shop

# Verificar swagger disponible
curl -s http://localhost:3000/api-docs | python3 -m json.tool | head -20
{
  "swagger": "2.0",
  "info": {"title": "OWASP Juice Shop"},
  "paths": {
    "/api/Users": {...},
    "/api/Products": {...},
    "/api/Feedbacks": {...}
  }
}

# Wapiti con Swagger: fuzzea todos los endpoints automáticamente
wapiti -u http://localhost:3000 \
  --swagger http://localhost:3000/api-docs \
  -m sql,xss,exec,ssrf,xxe \
  --color -f html -o /tmp/juiceshop_report

# Con autenticación JWT (Juice Shop usa Bearer tokens)
# Primero obtener el token
TOKEN=$(curl -s -X POST http://localhost:3000/api/Users/login \
  -H "Content-Type: application/json" \
  -d '{"email":"admin@juice-sh.op","password":"admin123"}' | \
  python3 -c "import json,sys; print(json.load(sys.stdin)['authentication']['token'])")

# Escanear con token Bearer
wapiti -u http://localhost:3000 \
  --swagger http://localhost:3000/api-docs \
  -H "Authorization: Bearer $TOKEN" \
  -m sql,xss,ssrf --color -f html -o /tmp/js_auth_report

# Nikto contra la API (limitado — no entiende rutas dinámicas)
nikto -h http://localhost:3000 -C all -o /tmp/js_nikto.html
# Solo detectará cabeceras ausentes y archivos estáticos conocidos

## WAPITI — Técnicas de evasión

# Delay entre peticiones (evitar rate limiting)
wapiti -u http://target.com --wait 2 --color -f html -o /tmp/r

# User-Agent personalizado (parecer un navegador real)
wapiti -u http://target.com \
  --user-agent "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" \
  --color -f html -o /tmp/r

# Vía proxy Tor (anonimizar el origen)
torify wapiti -u http://target.com --color -f html -o /tmp/r

# Vía Burp Suite (para ver y modificar las peticiones)
wapiti -u http://target.com --proxy http://127.0.0.1:8080 --color -f html -o /tmp/r

## NIKTO — Modos de evasión (-evasion)
1  → Random URI encoding (non-UTF8)
2  → Directory self-reference (/./)
3  → Premature URL ending
4  → Prepend long random string
5  → Fake parameter
6  → Tab as request spacer
7  → Random case sensitivity
8  → Use Windows directory separator (\)
A  → Use carriage return (0x0d) as separator
B  → Use binary value 0x0b as separator

# Nikto con evasión múltiple
nikto -h http://target.com -evasion 1,7 -useragent "Mozilla/5.0" -o /tmp/nikto_waf.html

# Delay entre peticiones
nikto -h http://target.com -timeout 3 -maxtime 600s -o /tmp/nikto_slow.html

# .github/workflows/security-scan.yml
name: Security Scan

on:
  push:
    branches: [main, develop]
  schedule:
    - cron: '0 6 * * 1'  # Lunes a las 6am

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - name: Start app
        run: docker-compose up -d && sleep 30

      - name: Nikto (quick fingerprint)
        run: |
          docker run --network host sullo/nikto \
            -h http://localhost:8080 -maxtime 120s \
            -Format json -o nikto_report.json || true
          cat nikto_report.json

      - name: Wapiti (deep fuzzing)
        run: |
          pip3 install wapiti3
          wapiti -u http://localhost:8080 \
            -m sql,xss,exec,file \
            --max-scan-time 300 \
            -f json -o /tmp/wapiti_report
          cat /tmp/wapiti_report/report.json

      - name: Fail on critical vulns
        run: |
          CRITICAL=$(cat /tmp/wapiti_report/report.json | python3 -c "
          import json,sys
          d=json.load(sys.stdin)
          vulns=d.get('vulnerabilities',{})
          critical=['sql_injection','exec','file_handling']
          count=sum(len(vulns.get(v,[])) for v in critical)
          print(count)
          ")
          if [ "$CRITICAL" -gt "0" ]; then
            echo "FAIL: $CRITICAL critical vulnerabilities found!"
            exit 1
          fi

# Script standalone de auditoría
cat > audit.sh << 'EOF'
#!/bin/bash
TARGET=$1
echo "[*] GhostAcademy Security Audit: $TARGET"
echo "[1/2] Nikto fingerprinting..."
nikto -h "$TARGET" -Format json -o /tmp/nikto.json -maxtime 120s

echo "[2/2] Wapiti fuzzing..."
wapiti -u "$TARGET" -m sql,xss,exec,file --max-scan-time 600 -f json -o /tmp/wapiti

echo "[*] Resumen:"
echo "Nikto: $(cat /tmp/nikto.json | python3 -c "import json,sys;d=json.load(sys.stdin);print(len(d.get('vulnerabilities',[])),'hallazgos')")"
echo "Wapiti: $(cat /tmp/wapiti/report.json | python3 -c "import json,sys;d=json.load(sys.stdin);v=d.get('vulnerabilities',{});print(sum(len(x) for x in v.values()),'vulnerabilidades')")"
EOF
chmod +x audit.sh
./audit.sh http://target.com