¿Quieres ser un DevSecOps? ¡Pues Necesitas Este Stack de Herramientas para Serlo!

Actualización (15 oct 2026): El 19 de marzo de 2026, un atacante con credenciales comprometidas publicó una versión maliciosa de Trivy (v0.69.4) y reescribió 76 de las 77 etiquetas de aquasecurity/trivy-action y las siete de aquasecurity/setup-trivy con código que robaba credenciales (GHSA-69fq-xp46-6x23, CVE-2026-33634). Un pipeline que usó una etiqueta reescrita durante la ventana de exposición ejecutó ese código con acceso a los secretos del job. Además, Kyverno 1.17 publicó la API policies.kyverno.io/v1 y anunció la retirada de ClusterPolicy; según la tabla de tipos de política, ImageValidatingPolicy es estable desde la 1.18, ClusterPolicy quedó obsoleta en la 1.19 y se retirará en la 1.20.

Supón que un pentest a dos días de la release encuentra tres cosas: una clave de AWS en el historial de Git, una dependencia transitiva con un CVE crítico y un bucket S3 con una política que concede acceso a "Principal": "*". Las tres se podían detectar automáticamente al entrar en el repositorio, cuando corregirlas suponía cambiar pocas líneas. El pentest manual y el DAST siguen siendo necesarios, pero al final del ciclo llegan tarde para este tipo de fallos.

Mi criterio es asignar cada control a la etapa en la que detecta el fallo con menos ruido y dejar escrito si bloquea o solo avisa.

El stack por etapas

EtapaQué cubreHerramientasPolítica
Pre-commit (local)Secretos en el cambiogitleaksBloquea el commit, pero se puede saltar
Pull requestSecretos; SAST sobre código nuevogitleaks, Semgrep, Opengrep, SonarQubeBloquea secretos y hallazgos SAST nuevos de severidad alta
BuildSBOM y CVE de dependenciasTrivy, Syft, Grype, OSV-Scanner, SnykBloquea HIGH y CRITICAL con parche
ImagenCVE del sistema base y de los paquetesTrivy, GrypeBloquea HIGH y CRITICAL con parche
IaC y manifiestosConfiguración inseguratrivy config, Checkov, KICSBloquea HIGH y CRITICAL
Publicación (registry)Firma y atestación por digestCosign, attest-build-provenanceRequisito para la admisión
Admisión y despliegueFirma, Pod Security, deriva respecto a GitKyverno, PSA, Argo CD, FluxLa admisión bloquea; la deriva se revierte solo con selfHeal
StagingCabeceras, cookies, configuración webZAPBloquea solo las reglas marcadas FAIL; el resto avisa
RuntimeComportamiento anómalo de procesosFalco, TetragonAlerta y respuesta

Avisar significa anotar el PR o abrir una alerta con responsable, sin detener el pipeline. Un gate que bloquea tiene que dar muy pocos falsos positivos: cada bloqueo injustificado enseña al equipo a saltárselo.

Secretos: gitleaks antes del commit y en el PR

gitleaks busca secretos en los parches de Git. En local se instala como hook con pre-commit, fijado a un commit (pre-commit autoupdate --freeze escribe el hash en lugar de la etiqueta):

repos:
  - repo: https://github.com/gitleaks/gitleaks
    rev: 83d9cd684c87d95d656c1458ef04895a7f1cbd8e  # frozen: v8.30.1
    hooks:
      - id: gitleaks

Cada desarrollador tiene que ejecutar pre-commit install, y cualquiera puede saltarse el hook con git commit --no-verify o SKIP=gitleaks. El hook da feedback rápido; el control que cuenta es el job de CI que escanea solo los commits del PR, más un escaneo programado (schedule:) de todo el historial, que encuentra lo que entró antes de activar el gate o sin pasar por un PR. Los hallazgos antiguos ya rotados se excluyen por su fingerprint en .gitleaksignore. Si un secreto ya llegó a un commit publicado, hay que rotarlo: reescribir el historial no revoca la credencial.

SAST sobre el código nuevo

Semgrep con --baseline-commit solo informa de los hallazgos que no existían en el commit base, --severity ERROR limita el informe a las reglas de severidad más alta y --error hace que salga con código 1 si encuentra alguno. Así bloqueas lo que introduce el PR sin heredar la deuda de todo el repositorio. Opengrep es un fork de Semgrep con licencia LGPL-2.1 que acepta las mismas reglas.

Con los nombres de octubre de 2024, el análisis de pull requests está en SonarQube Cloud y en SonarQube Server desde Developer Edition. En Jenkins, waitForQualityGate abortPipeline: true necesita un webhook de SonarQube hacia <jenkins>/sonarqube-webhook/ para que el pipeline falle según el quality gate.

El canal principal para los hallazgos es el propio PR: un SARIF subido a code scanning aparece como anotación en la línea afectada. En repositorios privados, code scanning exige GitHub Code Security. Jira queda para el riesgo aceptado.

Dependencias, SBOM e imagen

Una SBOM es un inventario de componentes, tengan o no vulnerabilidades; el informe de vulnerabilidades sale de cruzarlo con una base de advisories y cambia aunque la SBOM no cambie. Por eso guardas la SBOM de cada release: es lo que permite responder a un Log4Shell volviendo a escanear las SBOM archivadas en lugar de descargar cada imagen. Cómo hacerlo, y cómo firmar y atestar la SBOM con Cosign, está en el post sobre la cadena de suministro.

Trivy genera la SBOM con --format cyclonedx; en ese modo no busca vulnerabilidades, y el escaneo se hace después con trivy sbom. --ignore-unfixed muestra solo los CVE con parche y evita que un CVE sin parche en la imagen base bloquee un build en el que el equipo no puede corregir nada. Esos CVE siguen ahí: no bloquean el build, pasan al triaje con CISA KEV y EPSS y se reducen con una imagen base mínima fijada por digest. Con Grype, el gate equivalente sobre la misma SBOM es grype "sbom:./sbom.cdx.json" --fail-on high --only-fixed.

Cuando el paquete vulnerable es una dependencia transitiva, la corrección suele ser actualizar la dependencia directa que lo arrastra; si no hay versión que lo resuelva, overrides en package.json fuerza la versión en npm.

Infraestructura como código

El repositorio de tfsec recomienda migrar a Trivy, que usa el mismo motor para Terraform. trivy config revisa Terraform, CloudFormation, Dockerfiles, manifiestos de Kubernetes y charts de Helm. Checkov y KICS son alternativas.

Desde abril de 2023, los buckets nuevos se crean con S3 Block Public Access activado y las ACL desactivadas (anuncio de AWS). Hoy, un bucket público exige al menos dos cambios deliberados: poner block_public_policy = false y restrict_public_buckets = false en aws_s3_bucket_public_access_block, y adjuntar una política con "Principal": "*". Trivy marca lo primero con las comprobaciones AWS-0087 y AWS-0093, ambas HIGH. Las dos saltan también si falta aws_s3_bucket_public_access_block; prefiero declararlo de forma explícita antes que ignorar la regla.

Publicación, admisión y GitOps

La imagen se firma por digest con Cosign en modo keyless, y quien la consume verifica la identidad del firmante con cosign verify --certificate-identity https://github.com/org/repo/.github/workflows/release.yml@refs/heads/main --certificate-oidc-issuer https://token.actions.githubusercontent.com registry.example.com/app@sha256:<digest>. Una firma demuestra quién firmó un digest; no demuestra cómo ni dónde se construyó, que es lo que cubre la procedencia SLSA. El mismo release.yml la genera con actions/attest-build-provenance y se verifica con gh attestation verify.

En la admisión, una política de Kyverno (requiere Kyverno 1.18 o posterior) rechaza las imágenes sin una firma válida de esa identidad. La política completa está en Blindando la cadena de suministro. Pod Security Admission aplica el perfil restricted por namespace. PSA es estable desde Kubernetes 1.25, la versión que retiró PodSecurityPolicy:

apiVersion: v1
kind: Namespace
metadata:
  name: payments
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/enforce-version: v1.37
    pod-security.kubernetes.io/warn: restricted
    pod-security.kubernetes.io/audit: restricted

La admisión evalúa la petición cuando se crea o se modifica el pod; no ve lo que hace el proceso después. Eso es runtime, y lo trato en el post sobre Kubernetes, junto con el motivo de fijar enforce-version a la versión menor del clúster.

Argo CD y Flux reconcilian el clúster con Git. En Argo CD, syncPolicy.automated.selfHeal: true revierte los cambios hechos directamente en el clúster; por defecto está desactivado y la deriva persiste hasta el siguiente sync. Para que Git sea el registro auditable de cambios, quita además a las personas el permiso de escritura en el clúster mediante RBAC y protege la rama con revisiones obligatorias; sin protección, un force-push reescribe el historial. En la instalación estándar, el ClusterRole del controlador de Argo CD concede * sobre todos los recursos, así que su acceso entra en el modelo de amenazas.

Staging y runtime

En staging, ZAP (llamado ZAP by Checkmarx desde septiembre de 2024) ejecuta el baseline desde su imagen oficial:

#!/usr/bin/env bash
set -euo pipefail
# Baseline: spider + passive scan, no attacks.
# Only rules set to FAIL in .zap/rules.tsv exit 1; -I keeps WARN from failing.
docker run --rm -t -v "$(pwd)/.zap:/zap/wrk/:rw" \
  ghcr.io/zaproxy/zaproxy:2.17.0@sha256:7aaa659b0d43078febd82e29bad112285c370727e86ab8340444220e17d9f0d2 \
  zap-baseline.py -t https://staging.example.com -c rules.tsv -I

El baseline encuentra cabeceras de seguridad ausentes y errores de configuración; no prueba inyecciones, porque no ataca. Con -c pasas un fichero de reglas, montado en /zap/wrk, que asigna a cada ID de regla IGNORE, WARN o FAIL, separados por tabuladores; -g gen.conf genera uno inicial con todas en WARN. Solo bloquean las reglas marcadas FAIL: el script sale con 1 si alguna salta, y -I evita que los WARN devuelvan 2. zap-full-scan.py sí lanza ataques activos: solo contra staging y con autorización.

En runtime, Falco captura las syscalls (por defecto, con su sonda eBPF moderna) y alerta según reglas; no bloquea, y la respuesta queda en manos de otros sistemas. Tetragon puede además actuar en el kernel: Override impide la llamada y devuelve un error, y SIGKILL mata el proceso, aunque solo no siempre impide que la operación se complete.

Un workflow mínimo para pull requests

Este workflow ejecuta los gates del PR en tres jobs paralelos; el disparador schedule: semanal solo lanza el job de secretos, sobre todo el historial. La firma y la publicación pertenecen al pipeline de release.

name: security-gates

on:
  pull_request:
    branches: [main]
  schedule:
    - cron: "0 3 * * 1" # weekly full-history secret scan

permissions:
  contents: read

env:
  GITLEAKS_VERSION: "8.30.1"
  GITLEAKS_SHA256: "551f6fc83ea457d62a0d98237cbad105af8d557003051f41f3e7ca7b3f2470eb"
  SEMGREP_VERSION: "1.181.0"
  TRIVY_VERSION: "0.75.0"
  TRIVY_SHA256: "c6e65abddb348e25f10549df887045629cf28cc72453cd1c63acb717316b3f3f"

jobs:
  secrets:
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          fetch-depth: 0
          persist-credentials: false
      - name: Scan with gitleaks (PR range, or full history on schedule)
        env:
          BASE_SHA: ${{ github.event.pull_request.base.sha }}
        run: |
          set -euo pipefail
          f="gitleaks_${GITLEAKS_VERSION}_linux_x64.tar.gz"
          curl -sSfL -o "$RUNNER_TEMP/$f" \
            "https://github.com/gitleaks/gitleaks/releases/download/v${GITLEAKS_VERSION}/$f"
          echo "${GITLEAKS_SHA256}  $RUNNER_TEMP/$f" | sha256sum -c -
          tar -xzf "$RUNNER_TEMP/$f" -C "$RUNNER_TEMP" gitleaks
          if [ "$GITHUB_EVENT_NAME" = "pull_request" ]; then
            "$RUNNER_TEMP/gitleaks" git --redact --verbose --log-opts="${BASE_SHA}..HEAD" .
          else
            "$RUNNER_TEMP/gitleaks" git --redact --verbose .
          fi

  sast:
    if: github.event_name == 'pull_request'
    runs-on: ubuntu-24.04
    permissions:
      contents: read
      security-events: write # upload SARIF to code scanning
      actions: read          # needed by upload-sarif on private repos
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          fetch-depth: 0
          persist-credentials: false
      - name: Semgrep on new code only
        env:
          BASE_SHA: ${{ github.event.pull_request.base.sha }}
        run: |
          set -euo pipefail
          python3 -m venv "$RUNNER_TEMP/semgrep"
          "$RUNNER_TEMP/semgrep/bin/pip" install --quiet "semgrep==${SEMGREP_VERSION}"
          "$RUNNER_TEMP/semgrep/bin/semgrep" scan --config p/default \
            --baseline-commit "$BASE_SHA" --severity ERROR --error \
            --sarif-output=semgrep.sarif
      - name: Upload SARIF
        if: ${{ !cancelled() }}
        uses: github/codeql-action/upload-sarif@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
        with:
          sarif_file: semgrep.sarif
          category: semgrep

  iac-image-sbom:
    if: github.event_name == 'pull_request'
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
        with:
          persist-credentials: false
      - name: Install Trivy
        run: |
          set -euo pipefail
          f="trivy_${TRIVY_VERSION}_Linux-64bit.tar.gz"
          curl -sSfL -o "$RUNNER_TEMP/$f" \
            "https://github.com/aquasecurity/trivy/releases/download/v${TRIVY_VERSION}/$f"
          echo "${TRIVY_SHA256}  $RUNNER_TEMP/$f" | sha256sum -c -
          tar -xzf "$RUNNER_TEMP/$f" -C "$RUNNER_TEMP" trivy
      - name: IaC and manifests
        run: |
          set -euo pipefail
          "$RUNNER_TEMP/trivy" config --severity HIGH,CRITICAL --exit-code 1 .
      - name: Build image, generate SBOM, gate on vulnerabilities
        run: |
          set -euo pipefail
          docker build -t "app:${GITHUB_SHA}" .
          "$RUNNER_TEMP/trivy" image --format cyclonedx --output sbom.cdx.json "app:${GITHUB_SHA}"
          "$RUNNER_TEMP/trivy" sbom --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 sbom.cdx.json

Decisiones de diseño:

  • Cada Action está fijada a un commit completo con la versión en comentario. Una etiqueta es mutable: es lo que se explotó en el ataque a tj-actions/changed-files (CVE-2025-30066) de marzo de 2025 y en el de trivy-action de 2026. Fijar por SHA no protege de lo que la Action llama por etiqueta: según el advisory, un trivy-action fijado a un commit anterior al 9 de abril de 2025 podía cargar el setup-trivy comprometido.
  • El SHA-256 escrito en el workflow detecta una descarga modificada, no una release maliciosa; por eso fijas una versión conocida en lugar de latest. Trivy publica además bundles de Sigstore que se comprueban con cosign verify-blob.
  • permissions parte de contents: read y solo el job de SAST añade security-events: write. El disparador de los PR es pull_request, no pull_request_target: en un PR desde un fork, GitHub no pasa secretos al runner y el GITHUB_TOKEN es de solo lectura. Los ataques al runner, la federación OIDC y la verificación con gh attestation verify están en el post sobre secuestro de pipelines.

Qué bloquea, qué avisa y cómo caducan las excepciones

Empieza con pocas reglas de alta confianza, bloquea solo los hallazgos nuevos y amplía cuando el porcentaje de falsos positivos sea bajo.

Una excepción sin fecha acaba siendo permanente. Trivy carga .trivyignore por defecto y acepta una fecha de caducidad por entrada (exp:); pasada esa fecha, la entrada deja de aplicarse y el hallazgo vuelve a bloquear:

# Owner: team-payments. Reviewed: 2026-10-15.
# Not exploitable here: requires a setuid program using ncurses; the image has none.
CVE-2023-29491 exp:2026-12-31

Límites

  • Los escáneres de dependencias e imágenes solo ven lo que ya tiene advisory; ninguno detecta una vulnerabilidad que aún no se ha publicado.
  • SAST detecta patrones: los fallos de lógica y de autorización suelen escapársele, y el baseline de ZAP no ataca.
  • Si el runner está comprometido, el atacante puede saltarse los gates.
  • Una firma verificada no prueba que el build fuera íntegro, y la admisión no observa el runtime.
  • Los pipelines de ML añaden datasets y modelos que este stack no inspecciona; los trato en el post sobre MLOps, y los errores de adopción habituales, en el post sobre errores comunes en DevSecOps.

Referencias

Blog

¿Hablamos de seguridad?

Charlas, prensa o colaboraciones: escríbeme.