¿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.

Biblioteca Virtual

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:

  1. New → Web Service → conectar el repositorio → runtime Docker → plan Free.
  2. Auto-Deploy: Off. Esto es importante: Render ya no despliega por su cuenta, sino solo cuando el pipeline se lo pide.
  3. Copiar el Deploy Hook (una URL secreta que dispara un despliegue) y guardarlo en GitHub como secret RENDER_DEPLOY_HOOK.
  4. Guardar la URL pública como variable APP_URL, que Nuclei usa para el escaneo DAST.
  5. La SECRET_KEY real 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ó:

Pipeline en rojo

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".

Inyección SQL

💡 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.

Pipeline en verde

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.

Inyección SQL corregida

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