Introducción

Las vulnerabilidades no aparecen solo en la infraestructura. Vienen de código inseguro, dependencias desactualizadas y contenedores mal configurados. Mientras te defiendes contra DDoS, las aplicaciones vulnerables pueden ser explotadas directamente por atacantes.

En este artículo, aprenderás a implementar 5 capas de seguridad automática en tu pipeline de CI/CD usando herramientas gratuitas de GitHub y servicios open source. Cada una detecta un tipo diferente de riesgo: dependencias vulnerables, código inseguro, fallos lógicos e imágenes de contenedor comprometidas.

Lo mejor: todo funciona sin costes adicionales si usas GitHub Public, y hay opciones gratuitas para repos privados.

⚠️ Atención: Estas herramientas detectan y alertan sobre problemas, pero no lo corrigen todo automáticamente. Aún necesitas revisar y aprobar cada corrección. La seguridad es un proceso continuo, no una casilla que marcar.

Requisitos previos

Para implementar las medidas de este artículo, necesitas:

  • Un repositorio en GitHub (público o privado)
  • GitHub Actions habilitado (por defecto en repos nuevos)
  • Conocimientos básicos de YAML (workflows de GitHub Actions)
  • Una aplicación en Docker o código C#/.NET (los ejemplos son específicos, pero los conceptos se aplican a cualquier lenguaje)
  • Una cuenta de SonarCloud (gratuita para repos públicos y privados)

Los repos privados con el plan GitHub Pro/Team tienen acceso a algunas herramientas de seguridad gratuitas. Los repos públicos lo tienen todo gratis.

1. Dependabot: Detectar Dependencias Vulnerables

Dependabot es la primera línea de defensa. Verifica automáticamente tus dependencias contra bases de datos de vulnerabilidades conocidas (CVE) y abre pull requests con actualizaciones de seguridad.

Ejemplo real: Un paquete que usas desde hace 6 meses descubre un fallo crítico. Dependabot abre un PR automáticamente en cuestión de horas. Revisas, pruebas y haces merge.

Activar Dependabot en GitHub

  1. Accede a Settings → Code security and analysis
  2. Activa Dependabot alerts y Dependabot security updates
  3. Listo — Dependabot ya está monitorizando

Configuración Avanzada: dependabot.yml

Para controlar la frecuencia de actualizaciones y la agrupación de PRs, crea .github/dependabot.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
version: 2
updates:
  # Dependencias de .NET (NuGet)
  - package-ecosystem: "nuget"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "monday"
      time: "03:00"
    allow:
      - dependency-type: "all"
    pull-request-branch-name:
      separator: "/"
    reviewers:
      - "seu-usuario"
    assignees:
      - "seu-usuario"
    open-pull-requests-limit: 10  # Máximo 10 PRs abiertos al mismo tiempo

  # Imágenes Docker
  - package-ecosystem: "docker"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "monday"
      time: "04:00"
    open-pull-requests-limit: 5

  # GitHub Actions
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "monday"
      time: "05:00"

  # Python (si aplica)
  - package-ecosystem: "pip"
    directory: "/"
    schedule:
      interval: "weekly"
      day: "monday"
      time: "03:00"
    allow:
      - dependency-type: "direct"  # Solo dependencias directas, no transitivas

Automatización: Auto-merge de Actualizaciones Seguras

  • Una cuenta de SonarCloud (gratuita para repos públicos y privados) Si quieres que Dependabot haga merge automáticamente de ciertas actualizaciones (versiones patch, por ejemplo):
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
name: Auto-merge Dependabot updates

on: pull_request

jobs:
  auto-merge:
    if: github.actor == 'dependabot[bot]'
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: write
    steps:
      - uses: actions/checkout@v4

      - name: Enable auto-merge para patches de segurança
        run: |
          gh pr merge --auto --squash "${{ github.event.pull_request.number }}"
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        # Solo hacer merge automático si la actualización es MINOR o PATCH, no MAJOR

ℹ️ Información: Dependabot detecta vulnerabilidades en tiempo real. En 2024, el 42% de todos los PRs de seguridad los abren herramientas automáticas. Sin automatización, te quedas atrás.

2. GitHub Code Scanning: Análisis Estático con CodeQL

GitHub Code Scanning usa CodeQL (un lenguaje de consultas estáticas) para encontrar bugs de seguridad y code smells en tu código. Funciona en repositorios públicos y privados (con GitHub Pro).

Qué detecta: SQL injection, XSS, command injection, use-after-free, variables no inicializadas y más de 300 patrones inseguros.

Activar Code Scanning

  1. Accede a Settings → Code security and analysis
  2. Activa GitHub Advanced Security (si está disponible en tu cuenta)
  3. Code Scanning se activa automáticamente

Workflow Automático con CodeQL

GitHub genera automáticamente un workflow .github/workflows/github-code-scanning.yml. Personalízalo si es necesario:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
name: CodeQL Analysis

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]
  schedule:
    - cron: '0 3 * * 0'  # Todos los lunes a las 03:00 UTC

jobs:
  analyze:
    name: CodeQL Analyze
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write

    strategy:
      fail-fast: false
      matrix:
        language: [ 'csharp', 'python', 'javascript' ]  # Ajusta según tu proyecto

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v2
        with:
          languages: ${{ matrix.language }}
          queries: security-extended  # Usar consultas de seguridad extendidas

      - name: Autobuild (C#)
        if: matrix.language == 'csharp'
        run: |
          dotnet build --configuration Release

      - name: Perform CodeQL Analysis
        uses: github/codeql-action/analyze@v2
        with:
          category: "/language:${{ matrix.language }}"

Interpretar los Resultados

Los resultados aparecen en Security → Code scanning alerts:

  • Critical: Fallos que afectan a la seguridad (SQL injection, RCE)
  • High: Bugs que pueden ser explotados
  • Medium/Low: Malas prácticas o deuda técnica

Descartar Alertas de Forma Segura

No toda alerta es accionable. Si confirmas que una alerta es un falso positivo:

1
2
3
# En el código comentado:
// lgtm [cs/sql-injection] — validamos el input antes de usarlo en la query
var query = $"SELECT * FROM users WHERE id = {userId}";

📝 Ejemplo: CodeQL encontró un posible SQL injection en un informe. Resultado: descubrió que estabas concatenando IDs de usuario sin validación. Después de añadir parametrización, la alerta desapareció.

3. SonarCloud: Análisis SAST Profundo y Calidad de Código

SonarCloud va más allá de la seguridad — mide calidad de código, cobertura de pruebas, duplicación y code smells. Es gratuito para repos públicos y privados (con limitaciones).

Qué detecta además de seguridad: bugs, code smells, code coverage, deuda técnica, fallos de diseño.

Setup: Conectar GitHub a SonarCloud

  1. Accede a SonarCloud.io
  2. Inicia sesión con tu cuenta de GitHub
  3. Selecciona los repositorios a analizar
  4. Genera un token en My Account → Security → Generate Tokens

Workflow con SonarCloud

Añade .github/workflows/sonarcloud.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
name: SonarCloud Analysis

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]
  workflow_dispatch:

jobs:
  sonarcloud:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: read

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Necesario para el análisis de calidad

      - name: Set up .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '8.0.x'

      - name: Restore NuGet packages
        run: dotnet restore

      - name: SonarCloud Scan
        uses: SonarSource/sonarcloud-github-action@master
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}  # Genéralo en SonarCloud

      - name: Upload coverage to Codecov (opcional)
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage/coverage.xml

Archivo sonar-project.properties

Créalo en la raíz de tu proyecto:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
sonar.projectKey=seu-usuario_seu-projeto
sonar.organization=seu-usuario

# C#
sonar.sources=src
sonar.exclusions=**/bin/**,**/obj/**,**/tests/**
sonar.cs.opencover.reportsPaths=**/coverage.opencover.xml

# Pruebas
sonar.tests=tests
sonar.test.inclusions=**/Tests/**

# Code Coverage
sonar.coverage.exclusions=**/Tests/**

Badges de Calidad

Añádelos al README para mostrar el estado:

1
2
3
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=seu-usuario_seu-projeto&metric=alert_status)](https://sonarcloud.io/dashboard?id=seu-usuario_seu-projeto)
[![Code Coverage](https://sonarcloud.io/api/project_badges/measure?project=seu-usuario_seu-projeto&metric=coverage)](https://sonarcloud.io/dashboard?id=seu-usuario_seu-projeto)
[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=seu-usuario_seu-projeto&metric=security_rating)](https://sonarcloud.io/dashboard?id=seu-usuario_seu-projeto)

ℹ️ Información: SonarCloud analiza los Pull Requests automáticamente y deja comentarios en el código con sugerencias. Los desarrolladores reciben feedback en tiempo real, no al final del sprint.

4. OWASP ZAP: Pruebas Dinámicas de Seguridad (DAST)

OWASP ZAP (Zed Attack Proxy) es una prueba dinámica — accede a tu aplicación como lo haría un atacante y busca vulnerabilidades en tiempo de ejecución.

Diferencia entre SAST y DAST:

  • SAST (Code Scanning, SonarCloud): analiza el código fuente sin ejecutarlo
  • DAST (ZAP): ejecuta la aplicación y la ataca como un hacker real

Matriz de herramientas SAST vs DAST: CodeQL, SonarCloud, Trivy, OWASP ZAP, Dependabot y GitHub Security

Workflow con OWASP ZAP

Añade .github/workflows/owasp-zap.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
name: OWASP ZAP Scan

on:
  push:
    branches: [ main, develop ]
  schedule:
    - cron: '0 2 * * 0'  # Domingo a las 2 AM

jobs:
  zap-scan:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write

    steps:
      - uses: actions/checkout@v4

      - name: Build Docker image
        run: docker build -t seu-app:latest .

      - name: Start application
        run: |
          docker run -d --name app -p 8080:80 seu-app:latest
          sleep 10  # Esperar a que la app arranque

      - name: Run OWASP ZAP scan
        uses: zaproxy/[email protected]
        with:
          target: 'http://localhost:8080'
          rules_file_name: '.zap/rules.tsv'
          cmd_options: '-a'  # Análisis completo
          issue_title: 'OWASP ZAP: Vulnerabilidades encontradas'

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

      - name: Comment on PR (se DAST falhar)
        if: failure()
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: '🚨 OWASP ZAP encontrou vulnerabilidades. Veja o relatório em Artifacts.'
            })

      - name: Cleanup
        if: always()
        run: docker stop app && docker rm app

Configuración de Reglas (.zap/rules.tsv)

Personaliza qué vulnerabilidades debe bloquear ZAP:

1
2
3
4
5
6
7
8
# rule_id  alert_title  threshold  enabled
10000  Information  IGNORE  true
10001  Informational  IGNORE  true
40014  Cross Site Request Forgery  HIGH  true
40016  Cross Site Scripting (Reflected)  MEDIUM  true
40017  Cross Site Scripting (Stored)  HIGH  true
90024  SQL Injection  CRITICAL  true
90025  LDAP Injection  HIGH  true

Ejecutar ZAP Localmente para Pruebas

Antes de ponerlo en CI/CD, pruébalo localmente:

1
2
3
4
5
6
7
# Instalar ZAP
docker pull owasp/zap2docker-stable

# Ejecutar un baseline scan
docker run -t owasp/zap2docker-stable zap-baseline.py \
  -t http://seu-app.local:80 \
  -r report.html

⚠️ Atención: DAST solo funciona si tu aplicación está en ejecución. Asegúrate de que el build y el arranque de Docker sean rápidos. Los escaneos pueden tardar 5-10 minutos.

5. Trivy: Escaneo de Contenedores y Dependencias

Trivy verifica imágenes Docker y archivos de dependencias en busca de vulnerabilidades conocidas. Es rápido (segundos), agnóstico al lenguaje y se integra bien en CI/CD.

Qué escanea: imágenes Docker, archivos requirements.txt, package.json, *.csproj, etc.

Workflow con Trivy

Añade .github/workflows/trivy.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
name: Trivy Vulnerability Scan

on:
  push:
    branches: [ main, develop ]
    paths: [ 'Dockerfile', '*.csproj', 'requirements.txt', 'package.json' ]
  pull_request:
    branches: [ main ]
  schedule:
    - cron: '0 1 * * 0'  # Domingo a la 1 AM

jobs:
  trivy-scan:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write

    steps:
      - uses: actions/checkout@v4

      - name: Run Trivy vulnerability scan (filesystem)
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'  # Escaneo del filesystem
          scan-ref: '.'
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'HIGH,CRITICAL'

      - name: Upload Trivy results to GitHub Security
        uses: github/codeql-action/upload-sarif@v2
        if: always()
        with:
          sarif_file: 'trivy-results.sarif'

      - name: Build Docker image (se houver Dockerfile)
        if: hashFiles('Dockerfile') != ''
        run: docker build -t seu-app:${{ github.sha }} .

      - name: Scan Docker image with Trivy
        if: hashFiles('Dockerfile') != ''
        uses: aquasecurity/trivy-action@master
        with:
          input: 'seu-app:${{ github.sha }}'
          format: 'table'
          exit-code: '1'  # Fallar si se encuentran vulnerabilidades
          severity: 'CRITICAL'  # Solo critical, no warning

Ejecutar Trivy Localmente

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Instalar Trivy
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sh -s -- -b /usr/local/bin

# Escanear el directorio local
trivy fs .

# Escanear una imagen Docker
trivy image seu-app:latest

# Solo vulnerabilidades críticas
trivy image --severity CRITICAL seu-app:latest

Interpretar la Salida de Trivy

1
2
3
vuln-id       severity  package
CVE-2024-1234 CRITICAL  openssl/1.0.2
CVE-2024-5678 HIGH      curl/7.32.0

Cada CVE tiene un enlace a los detalles. Si es crítico, debes actualizar el paquete de inmediato.

📝 Ejemplo: Trivy encontró CVE-2024-1234 en una imagen base de Ubuntu. Actualizas la imagen, la reconstruyes y el escaneo pasa. Todo en menos de 1 minuto.

6. Ejemplo Práctico: Workflow Completo de CI/CD

Aquí tienes un workflow que ejecuta las 5 capas de seguridad en cada push:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
name: Segurança Completa

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

jobs:
  # 1. Dependabot ya se ejecuta automáticamente (integrado en GitHub)
  
  # 2. CodeQL
  codeql:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write
    steps:
      - uses: actions/checkout@v4
      - uses: github/codeql-action/init@v2
        with:
          languages: csharp
      - run: dotnet build --configuration Release
      - uses: github/codeql-action/analyze@v2

  # 3. SonarCloud
  sonarcloud:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '8.0.x'
      - run: dotnet restore
      - uses: SonarSource/sonarcloud-github-action@master
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

  # 4. Trivy (filesystem + imagen Docker)
  trivy:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write
    steps:
      - uses: actions/checkout@v4
      - uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          format: 'sarif'
          output: 'trivy-results.sarif'
      - uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: 'trivy-results.sarif'

  # 5. OWASP ZAP (solo en main)
  dast:
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    permissions:
      contents: read
      security-events: write
    steps:
      - uses: actions/checkout@v4
      - run: docker build -t seu-app:latest .
      - run: docker run -d --name app -p 8080:80 seu-app:latest && sleep 10
      - uses: zaproxy/[email protected]
        with:
          target: 'http://localhost:8080'
          rules_file_name: '.zap/rules.tsv'
      - if: always()
        run: docker stop app

Tiempo Total de Ejecución

  • CodeQL: ~3 minutos
  • SonarCloud: ~4 minutos
  • Trivy: ~30 segundos
  • OWASP ZAP: ~8 minutos (solo en main)

Total: ~10-15 minutos por push (sin paralelización). Con paralelización en GitHub Actions, se ejecutan en paralelo.

7. Consejos y Buenas Prácticas

  • 1. Equilibra falsos positivos y seguridad: No ignores todas las alertas, pero tampoco paralices el pipeline. Ajusta la severidad mínima a CRITICAL/HIGH, no MEDIUM.

  • 2. Organiza la revisión de vulnerabilidades: Designa a una persona o equipo responsable de revisar y cerrar/resolver las alertas de seguridad. No dejes que se acumulen.

  • 3. Integración con chat: Conecta GitHub Issues/Security Alerts a Slack/Discord. Recibe notificaciones en tiempo real.

  • 4. Status checks: Configura Status Checks para bloquear PRs con fallos de seguridad críticos. Actions → Settings → Status Checks.

  • 5. Pruebas regulares en staging: Ejecuta DAST (ZAP) regularmente contra tu entorno de staging (no solo en producción). Detecta problemas antes del deploy.

Resumen Objetivo

  • Dependabot — monitoriza dependencias contra CVE en tiempo real; abre PRs con actualizaciones de seguridad automáticamente cuando descubre vulnerabilidades.

  • GitHub Code Scanning (CodeQL) — análisis estático nativo de GitHub que detecta más de 300 patrones inseguros (SQL injection, XSS, RCE) sin coste adicional.

  • SonarCloud — análisis SAST profundo que mide calidad de código, security hotspots, code coverage y deuda técnica; gratuito para repos públicos.

  • OWASP ZAP — prueba dinámica (DAST) que ejecuta la aplicación y simula ataques reales para encontrar vulnerabilidades explotables en runtime.

  • Trivy — escaneo rápido de filesystems e imágenes Docker en busca de vulnerabilidades conocidas en dependencias; se ejecuta en segundos.

Lee También

Referencias