Biblioteca Virtual: escaneo de vulnerabilidades con Bandit, Gitleaks, OSV-Scanner, Grype y Nuclei
¿Qué pasa si subes a producción una consulta SQL vulnerable, una contraseña escrita en el código o una librería con fallas conocidas? Normalmente nadie se entera… hasta que alguien la explota. En este artículo muestro c
¿Qué pasa si subes a producción una consulta SQL vulnerable, una contraseña escrita en el código o una librería con fallas conocidas? Normalmente nadie se entera… hasta que alguien la explota.
En este artículo muestro cómo construí un pipeline DevSecOps que revisa automáticamente la seguridad de una aplicación web en cada push y solo la publica en la nube si pasa todos los escaneos. Usé cinco herramientas gratuitas de la lista de herramientas de escaneo de vulnerabilidades de OWASP, distintas a las que solemos usar en los laboratorios (SonarQube, Snyk u OWASP ZAP).
🔗 Repositorio: https://github.com/JhonyVargas/biblioteca-virtual-devsecops
🌐 App en vivo: https://biblioteca-virtual-devsecops.onrender.com
🎥 Video: al final del artículo
1. La aplicación: Biblioteca Virtual
Es una aplicación web sencilla hecha con Python + Flask + SQLite para gestionar el catálogo de una biblioteca: registrar, buscar, editar y eliminar libros, y marcarlos como prestados o devueltos.
Para que el escaneo tenga algo que encontrar, la primera versión tiene cuatro vulnerabilidades intencionales, muy comunes en proyectos reales:
| # | Vulnerabilidad | Dónde |
|---|---|---|
| 1 | Inyección SQL en el buscador | app.py |
| 2 |
Secreto escrito en el código (SECRET_KEY) |
app.py |
| 3 |
Modo debug activo expuesto en 0.0.0.0
|
app.py |
| 4 | Dependencias desactualizadas con CVEs (Flask 2.3.0, Werkzeug 2.3.7, Jinja2 3.1.2, gunicorn 21.2.0) | requirements.txt |
Por ejemplo, el buscador arma la consulta concatenando lo que escribe el usuario:
# ❌ Vulnerable: la entrada del usuario se mete directo en el SQL
sql = f"SELECT * FROM libros WHERE titulo LIKE '%{q}%' OR autor LIKE '%{q}%' ORDER BY titulo"
libros = db.execute(sql).fetchall()
2. Las herramientas
Cada herramienta revisa una capa distinta de la aplicación:
| Herramienta | Tipo | ¿Qué analiza? |
|---|---|---|
| Bandit | SAST | El código fuente Python en busca de patrones inseguros |
| Gitleaks | Detección de secretos | Contraseñas, tokens y llaves en todo el historial de Git |
| OSV-Scanner (Google) | SCA | Las dependencias, contra la base de datos abierta de vulnerabilidades OSV.dev |
| Grype (Anchore) | Escaneo de contenedores | La imagen Docker completa: sistema operativo + paquetes Python |
| Nuclei (ProjectDiscovery) | DAST | La aplicación ya desplegada, atacándola desde afuera con miles de plantillas |
La idea es cubrir el ciclo completo: código → secretos → dependencias → contenedor → aplicación en ejecución.
3. El pipeline en GitHub Actions
Todo vive en .github/workflows/security-pipeline.yml. En cada push a main ocurre esto:
push ──► Bandit ───────┐
Gitleaks ─────┤
OSV-Scanner ──┼──► ¿todo OK? ──► Deploy en Render ──► Nuclei (DAST)
Grype ────────┘
Los cuatro escaneos corren en paralelo. El despliegue tiene needs: sobre los cuatro, así que si uno solo falla, la app no se publica.
Así se ven los jobs principales (todas las herramientas se ejecutan con Docker o pip, sin instalar nada raro):
jobs:
sast-bandit:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install bandit
- run: bandit -r . -x ./.venv,./venv -ll
secrets-gitleaks:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0 # revisa TODO el historial, no solo el último commit
- run: |
docker run --rm -v "$PWD:/repo" zricethezav/gitleaks:latest \
detect --source /repo --redact -v
sca-osv:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: |
docker run --rm -v "$PWD:/src" ghcr.io/google/osv-scanner:latest \
scan source -r /src
image-grype:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: docker build -t biblioteca:ci .
- run: |
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
anchore/grype:latest biblioteca:ci --only-fixed --fail-on high
deploy:
needs: [sast-bandit, secrets-gitleaks, sca-osv, image-grype]
if: github.event_name != 'pull_request'
runs-on: ubuntu-latest
steps:
- run: curl -fsS -X POST "${{ secrets.RENDER_DEPLOY_HOOK }}"
dast-nuclei:
needs: deploy
runs-on: ubuntu-latest
steps:
# (espera a que /health responda y luego...)
- run: |
docker run --rm projectdiscovery/nuclei:latest \
-u "${{ vars.APP_URL }}" -severity low,medium,high,critical
4. Despliegue en la nube con Render
Elegí Render porque tiene un plan gratuito que despliega contenedores Docker directo desde GitHub. La configuración clave:
- New → Web Service → conectar el repositorio → runtime Docker → plan Free.
- Auto-Deploy: Off. Esto es importante: Render ya no despliega por su cuenta, sino solo cuando el pipeline se lo pide.
- Copiar el Deploy Hook (una URL secreta que dispara un despliegue) y guardarlo en GitHub como secret
RENDER_DEPLOY_HOOK. - Guardar la URL pública como variable
APP_URL, que Nuclei usa para el escaneo DAST. - La
SECRET_KEYreal se define como variable de entorno en Render, nunca en el código.
El Dockerfile corre la app con gunicorn y con un usuario sin privilegios:
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
RUN useradd --create-home appuser && mkdir -p /app/data && chown -R appuser /app
USER appuser
CMD ["sh", "-c", "gunicorn --bind 0.0.0.0:${PORT:-10000} --workers 2 app:app"]
5. Resultados: el "antes" 🔴
En el primer push, los cuatro escaneos fallaron y el despliegue se bloqueó:
Bandit: 3 hallazgos en el código
>> Issue: [B608:hardcoded_sql_expressions] Possible SQL injection vector
through string-based query construction.
>> Issue: [B201:flask_debug_true] A Flask app appears to be run with debug=True,
which exposes the Werkzeug debugger and allows the execution of arbitrary code.
Severity: High
>> Issue: [B104:hardcoded_bind_all_interfaces] Possible binding to all interfaces.
Gitleaks: secreto expuesto
Finding: SECRET_KEY = "REDACTED"
RuleID: generic-api-key
File: app.py
Line: 16
WRN leaks found: 1
OSV-Scanner: 32 vulnerabilidades en las dependencias
Total 7 packages affected by 32 known vulnerabilities
(0 Critical, 14 High, 18 Medium, 0 Low) from 1 ecosystem.
| PYSEC-2023-62 | 8.7 | flask | 2.3.0 | fixed: 2.3.2 |
| PYSEC-2026-1434 | 8.2 | gunicorn | 21.2.0 | fixed: 22.0.0 |
| PYSEC-2026-1472 | 8.8 | jinja2 | 3.1.2 | fixed: 3.1.5 |
| PYSEC-2023-221 | 7.5 | werkzeug | 2.3.7 | fixed: 2.3.8 |
...
Grype: el contenedor también hereda problemas
Además de las mismas librerías Python, Grype encontró algo que ninguna otra herramienta vio: un paquete vulnerable del sistema operativo de la imagen base (zlib1g de Debian). Esto demuestra por qué conviene escanear la imagen final y no solo el requirements.txt.
NAME INSTALLED FIXED IN TYPE VULNERABILITY SEVERITY
werkzeug 2.3.7 3.0.3 python GHSA-2g68-c3qc-8985 High
gunicorn 21.2.0 22.0.0 python GHSA-w3h3-4rj7-4ph4 High
flask 2.3.0 2.3.2 python GHSA-m2qf-hxjv-5gpq High
zlib1g 1:1.3... ...deb13u1 deb CVE-2026-76844 High
Explotando la inyección SQL (y un dato curioso)
En la app desplegada probé el payload clásico ' OR 1=1 -- y Render respondió 403 Forbidden: tiene un firewall (WAF) delante que bloquea ese patrón. Pero con una variante un poco distinta:
zzz%' OR titulo LIKE '%
…la búsqueda devolvió todos los libros, aunque ninguno contiene "zzz".
💡 Lección: un WAF ayuda, pero no reemplaza corregir el código. Los atacantes prueban variantes hasta encontrar una que pase. Bandit encontró el problema de raíz leyendo el código, sin necesidad de atacar nada.
6. Corrigiendo las vulnerabilidades
1. Inyección SQL → consulta parametrizada. La base de datos trata la entrada como dato, nunca como código:
# ✅ Seguro
sql = "SELECT * FROM libros WHERE titulo LIKE ? OR autor LIKE ? ORDER BY titulo"
libros = db.execute(sql, (f"%{q}%", f"%{q}%")).fetchall()
2. Secreto en el código → variable de entorno:
app.config["SECRET_KEY"] = os.environ.get("SECRET_KEY") or os.urandom(32)
Ojo: aunque lo borres del código, el secreto sigue en el historial de Git, por eso Gitleaks lo sigue detectando. La práctica correcta es considerarlo comprometido: se genera uno nuevo (en Render) y el hallazgo antiguo se registra en .gitleaksignore como ya atendido.
3. Modo debug → desactivado por defecto:
app.run(host="127.0.0.1", port=5000, debug=os.environ.get("FLASK_DEBUG") == "1")
4. Dependencias → versiones actuales:
Flask==3.1.3
Werkzeug==3.1.9
Jinja2==3.1.6
gunicorn==27.0.1
5. Imagen base → actualizar paquetes del sistema y pip en el Dockerfile:
RUN apt-get update && apt-get upgrade -y && rm -rf /var/lib/apt/lists/*
RUN pip install --no-cache-dir --upgrade pip && pip install --no-cache-dir -r requirements.txt
7. Resultados: el "después" 🟢
Con las correcciones subidas, los cuatro escaneos pasaron en verde y el pipeline desplegó la aplicación en Render de forma automática, sin ninguna intervención manual. Justo después, Nuclei comenzó a analizar la aplicación ya publicada, probándola desde afuera como lo haría un atacante.
| Etapa | Antes 🔴 | Después 🟢 |
|---|---|---|
| Bandit (código) | 3 hallazgos | 0 hallazgos |
| Gitleaks (secretos) | 1 secreto expuesto | Secreto rotado, sin hallazgos nuevos |
| OSV-Scanner (dependencias) | 32 vulnerabilidades | 0 vulnerabilidades |
| Grype (imagen Docker) | Falla por severidad alta | Pasa |
| Despliegue en Render | Bloqueado | Automático |
Y el mismo payload zzz%' OR titulo LIKE '% ahora no devuelve ningún libro: la consulta parametrizada busca literalmente ese texto.
8. Video de la demostración
Conclusiones
- Cada herramienta ve una capa distinta. Bandit leyó el código, Gitleaks el historial, OSV-Scanner las dependencias, Grype encontró una falla del sistema operativo que nadie más vio y Nuclei probó la app real. Ninguna sola es suficiente.
- El pipeline convierte la seguridad en una regla, no en una buena intención. Es imposible publicar código vulnerable por descuido: si un escaneo falla, no hay despliegue.
- Los secretos subidos a Git no se "borran". Quedan en el historial; hay que rotarlos.
- Un WAF no reemplaza al código seguro. El payload clásico fue bloqueado, una variante no.
- Todo esto es gratis: GitHub Actions, Render y las cinco herramientas son de código abierto o tienen planes gratuitos.
Todo el código está en el repositorio, ¡siéntete libre de clonarlo y probar el pipeline! 🚀
🔗 https://github.com/JhonyVargas/biblioteca-virtual-devsecops
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.



