OWASP ZAP y Docker, automatizando escaneos de seguridad.
OWASP ZAP es una herramienta open source orientada a los escaneos de vulnerabilidades web. Sus funcionalidades y datos proporcionados, su capacidad para integrarse en flujos de trabajo, así como la facilidad de uso, han hecho de esta herramienta un referente del sector de la ciberseguridad que, además, es gratuita.
En este artículo veremos cómo configurar y utilizar OWASP ZAP desde un contenedor Docker, ejecutándolo en modo sin interfaz gráfica (headless) y lanzando comandos a través de su API REST. Al final del proceso, aprenderemos a generar y analizar informes detallados de vulnerabilidades detectadas.
Preparación del entorno
Necesitaremos contar con lo siguiente:
- Docker: puede obtenerse de diversas formas dependiendo del sistema operativo, os recomendamos acceder a https://docker.com.
- La imagen de docker de OWASP-ZAP: podéis ver más información aquí: https://www.zaproxy.org/docs/docker/about/.
- Un objetivo para escanear: Por motivos éticos, asegúrate de contar con los permisos necesarios para realizar pruebas de seguridad sobre la aplicación web que vayas a escanear.
Para este caso en concreto usaremos la imagen de zaproxy/zap-weekly:latest que se actualiza semanalmente y es la que nos ha parecido más completa.
Podéis encontrar más información en el repositorio de GitHub: https://github.com/h3st4k3r/OWASP-ZAP/.
Descargar la imagen de OWASP ZAP
Para poder descargar la imagen de OWASP ZAP tendremos que poner lo siguiente:
docker pull zaproxy/zap-weekly:latestCon esto ya tendremos nuestra imagen descargada y lista para usarse.
Podeis comprobar que realmente disponemos de la máquina si ejecutamos el siguiente comando:
docker imagesQue devolverá algo así:
REPOSITORY TAG IMAGE ID CREATED SIZE
zaproxy/zap-weekly latest abcdef123456 X days ago Y MBIniciar el contenedor
Antes de arrancar el contenedor, vamos a tener en cuenta una serie de configuraciones. Por un lado nos interesa acceder a la API, por lo que necesitamos conseguir una API KEY. Por otro lado nos interesa poder acceder al contenedor desde cualquier IP de nuestra red, por tanto pondremos el campo host a 0.0.0.0.
Para poder disponer de nuestra API KEY generaremos un código random para ponerlo manualmente, deberemos escribir lo siguiente:
openssl rand -hex 16Que en nuestro caso nos ha devuelto: a8df14b272a794e4d1d178b1ebba1bbf.
Ahora ya estamos preparados para arrancar nuestro contenedor. En nuestro caso lo dejamos en el puerto 8080, pero podéis elegir cualquier valor en los parámetros contenidos.
docker run -d --name owasp-zap \
-p 8080:8080 \
zaproxy/zap-weekly:latest \
zap.sh -daemon -host 0.0.0.0 -port 8080 \
-config "api.addrs.addr.name=.*" \
-config "api.addrs.addr.regex=true" \
-config "api.key=a8df14b272a794e4d1d178b1ebba1bbf"-u zap: Ejecuta el contenedor como el usuariozap.-p 8080:8080: Expone el puerto 8080 del contenedor al host para acceder a la API REST.-i -t: Permite la interacción con el contenedor (aunque en este caso es en modo daemon).zap.sh -daemon: Inicia ZAP en modo demonio (sin interfaz gráfica, lo cual mejora bastante el rendimiento de ZAP).-host 0.0.0.0: Permite que ZAP acepte conexiones en todas las interfaces de red.-port 8080: Define el puerto de la API REST.-config api.addrs.addr.name=.*: Permite que la API acepte peticiones desde cualquier dirección.-config api.addrs.addr.regex=true: Activa el uso de expresiones regulares en las configuraciones de direcciones.- -config api.key=a8df14b272a794e4d1d178b1ebba1bbf: Nuestra clave de la API que hemos generado anteriormente.
Si navegamos a nuestro localhost:8080 veremos que tenemos la documentación de la API, así como los links de referencia del propio ZAP.
Para ahorraros leer toda la documentación, aunque es algo recomendable, vamos a ver lo que más nos puede interesar, es decir, lanzar escaneos, lanzar el spider, ver el estado del progreso de los mismos y generar el informe (ya sea por defecto o con modificaciones que hagamos para personalizarlo).
Lanzar el spider para rastrear los enlaces de una web:
curl "http://localhost:8080/JSON/spider/action/scan/?url=https://webanalizar.com&apikey=a8df14b272a794e4d1d178b1ebba1bbf"
Ver el progreso del spider:
curl "http://localhost:8080/JSON/spider/view/status/?scanId=0&apikey=a8df14b272a794e4d1d178b1ebba1bbf"Lanzar un escaneo activo:
curl "http://localhost:8080/JSON/ascan/action/scan/?url=https://webanalizar.com&apikey=a8df14b272a794e4d1d178b1ebba1bbf"
Ver el progreso del escaneo:
curl "http://localhost:8080/JSON/ascan/view/status/?scanId=0&apikey=a8df14b272a794e4d1d178b1ebba1bbf"Ver las URLs detectadas en el spider:
curl "http://localhost:8080/JSON/core/view/urls/?apikey=a8df14b272a794e4d1d178b1ebba1bbf"Obtener alertas generadas:
curl "http://localhost:8080/JSON/core/view/alerts/?baseurl=https://h3st4k3r.com&apikey=a8df14b272a794e4d1d178b1ebba1bbf"Generar reporte HTML:
curl "http://localhost:8080/OTHER/core/other/htmlreport/?apikey=a8df14b272a794e4d1d178b1ebba1bbf" -o reporte.htmlFiltrar contenido de los reportes:
Si os habéis fijado en la petición anterior, estamos generando un reporte con todo lo que salga. En ningún momento hemos puesto algo similar a «sacar reporte del escaneo con ID X». Para poder sacar los informes de los escaneos en específico. Si queremos centrarnos exclusivamente en un escaneo específico, podemos combinar comandos para filtrar resultados o usar herramientas como jq para procesar el JSON devuelto por la API. Podemos escribir por ejemplo:
curl -X GET "http://localhost:8080/JSON/ascan/view/scans/" | jq '.scans[] | select(.id=="1")'O podemos sacarlo en formato json ya filtrado y luego postprocesarlo:
curl -X GET "http://localhost:8080/JSON/ascan/view/scanResults/?scanId=1&apikey=a8df14b272a794e4d1d178b1ebba1bbf" > scan_results.jsonCon esto ya tendríamos todo lo necesario para comenzar a automatizar el uso de OWASP ZAP en un entorno Docker a través de su API. Ahora es cuestión de ir ajustando y experimentando para adaptarlo a las necesidades de tus proyectos.
Ahora, como ya sabemos todo esto, podemos automatizarlo todo para que se instale en Debian automáticamente Docker junto con todos los requisitos que necesitamos y luego se ejecute el escaneo mediante un domino dado. Podéis encontrar el código en el repositorio que os hemos compartido al principio.
#!/usr/bin/env python3
import os
import sys
import subprocess
import time
import requests
def install_requirements():
"""Installs required packages on a Debian-based system."""
print("Instalando los requisitos...")
subprocess.run(["sudo", "apt", "update"], check=True)
subprocess.run(["sudo", "apt", "install", "-y", "docker.io", "python3-pip"], check=True)
subprocess.run(["sudo", "systemctl", "enable", "--now", "docker"], check=True)
print("Requisitos instalados correctamente.")
def start_owasp_zap():
"""Starts the OWASP ZAP Docker container."""
print("Iniciando OWASP ZAP...")
subprocess.run([
"docker", "run", "-d", "--name", "owasp-zap", "-u", "zap",
"-p", "8080:8080", "zaproxy/zap-weekly:latest",
"zap.sh", "-daemon", "-host", "0.0.0.0", "-port", "8080",
"-config", "api.addrs.addr.name=.*", "-config", "api.addrs.addr.regex=true"
], check=True)
print("OWASP ZAP iniciado correctamente. Esperando a que se inicialice...")
time.sleep(15)
def stop_owasp_zap():
"""Stops and removes the OWASP ZAP container."""
print("Deteniendo OWASP ZAP...")
subprocess.run(["docker", "rm", "-f", "owasp-zap"], check=True)
print("OWASP ZAP detenido y eliminado correctamente.")
def perform_scan(domain):
"""Performs a Spider and Active Scan on the given domain."""
base_url = "http://localhost:8080"
print(f"Ejecutando Spider para {domain}...")
spider_response = requests.get(f"{base_url}/JSON/spider/action/scan/",
params={"url": f"http://{domain}"})
spider_id = spider_response.json().get("scan")
while True:
status = requests.get(f"{base_url}/JSON/spider/view/status/",
params={"scanId": spider_id}).json().get("status")
if status == "100":
break
time.sleep(5)
print(f"Spider completado para {domain}.")
print(f"Ejecutando Active Scan para {domain}...")
ascan_response = requests.get(f"{base_url}/JSON/ascan/action/scan/",
params={"url": f"http://{domain}"})
ascan_id = ascan_response.json().get("scan")
while True:
status = requests.get(f"{base_url}/JSON/ascan/view/status/",
params={"scanId": ascan_id}).json().get("status")
if status == "100":
break
time.sleep(5)
print(f"Active Scan completado para {domain}.")
print(f"Generando informe para {domain}...")
html_report = requests.get(f"{base_url}/OTHER/core/other/htmlreport/").text
with open(f"owasp-zap-report-{domain}.html", "w") as file:
file.write(html_report)
print(f"Informe generado: owasp-zap-report-{domain}.html")
def main():
if len(sys.argv) < 2 or "--help" in sys.argv:
print("Uso:")
print(" owaspzap-auto.py domain.com")
print(" owaspzap-auto.py domain.com domain2.com")
print(" owaspzap-auto.py --help")
return
domains = sys.argv[1:]
try:
install_requirements()
start_owasp_zap()
for domain in domains:
perform_scan(domain)
except Exception as e:
print(f"Error: {e}")
finally:
stop_owasp_zap()
if __name__ == "__main__":
main()Si te ha resultado útil o tienes alguna duda, no dudes en compartir tus comentarios o experiencias ¡Nos encantará saber cómo lo estás aplicando!
