Saltar al contenido

Seguridad de la cadena de suministro de software: SBOM, firma de artefactos y dependencias

    Seguridad de la cadena de suministro de software:

    SBOM, firma de artefactos y dependencias

    DevSecOps  |  unfantasmaenelsistema.com

    En diciembre de 2020 se supo que unos 18.000 clientes de SolarWinds habían instalado, por su propio canal de actualizaciones y con la firma legítima del fabricante, una puerta trasera. En 2024 se descubrió de casualidad —por unos milisegundos de latencia extra en un login SSH— una puerta trasera incrustada durante dos años en xz/liblzma, una librería de compresión que está en prácticamente toda distribución de Linux. Entre medias, decenas de paquetes maliciosos en npm y PyPI con nombres casi idénticos a los populares. El patrón es siempre el mismo: no atacan tu código, atacan algo en lo que tu código confía.

    La cadena de suministro de software es todo lo que entra en tu producto sin que tú lo hayas escrito: dependencias directas y transitivas, imágenes base de contenedor, el compilador, las acciones de CI/CD, el registro del que descargas y el propio mecanismo de actualización. Este artículo recorre esa superficie de ataque y las defensas que hoy son realistas: inventario (SBOM), fijación de versiones, firma y verificación de artefactos, y análisis continuo de vulnerabilidades.

    Qué aprenderás en este artículo

    Qué partes de tu build son «cadena de suministro» y por qué son un objetivo · Los tipos de ataque reales: typosquatting, confusión de dependencias, mantenedor comprometido, build troyanizado · Qué es un SBOM (CycloneDX, SPDX) y para qué sirve de verdad —y para qué no · Firma y verificación con Sigstore/cosign, procedencia SLSA y npm provenance · Fijar versiones y hashes con lockfiles y –require-hashes, y análisis con osv-scanner y Dependabot

    1. La superficie de ataque: dónde se cuela el atacante

    Un proyecto moderno de tamaño medio arrastra cientos o miles de paquetes de terceros. La mayoría no los eligió nadie: son dependencias transitivas, es decir, dependencias de tus dependencias. Cada una es código que se ejecuta con los mismos privilegios que el tuyo, y cada una tiene un mantenedor —a veces una sola persona, a veces una cuenta abandonada— cuyo compromiso te afecta directamente.

    Pero las dependencias son solo una parte. El atacante también mira el sistema de build (un plugin de Maven o Gradle, un script de postinstall de npm), el pipeline de CI/CD (una GitHub Action referenciada por etiqueta móvil que cambia bajo tus pies, secretos expuestos en logs), el registro (typosquatting, cuentas sin 2FA) y el canal de actualización del producto ya desplegado, que es exactamente lo que se usó en SolarWinds.

    EslabónQué puede comprometer el atacanteEjemplo real
    Dependencia directa/transitivaPublicar una versión maliciosa de un paquete legítimoevent-stream (npm, 2018)
    Registro de paquetesSubir un paquete con nombre parecido o con prioridad de resoluciónTyposquatting en PyPI; dependency confusion (2021)
    Cuenta de mantenedorRobo de credenciales o token y publicación firmada como el autorua-parser-js, coa, rc (npm, 2021)
    Sistema de buildInyectar código en tiempo de compilación, no en el fuentexz/liblzma (2024); SolarWinds Orion (2020)
    CI/CDAction o runner comprometido que altera el artefacto o roba secretosCodecov bash uploader (2021)
    Canal de actualizaciónDistribuir el troyano firmado por el propio fabricanteSolarWinds (2020); NotPetya vía M.E.Doc (2017)

    2. Los ataques, por tipo

    2.1 Typosquatting y slopsquatting

    El atacante publica un paquete con un nombre a un carácter de distancia de uno popular (python-nmap vs nmap-python, crossenv vs cross-env) y espera a que alguien se equivoque al teclear o copie mal un comando de instalación. La variante moderna, el slopsquatting, aprovecha que los asistentes de IA a veces «alucinan» nombres de paquetes que no existen: el atacante registra esos nombres inventados y espera a que alguien instale lo que la IA le sugirió sin comprobarlo.

    2.2 Confusión de dependencias

    Muchas empresas tienen paquetes internos (acme-auth, acme-utils) en un registro privado. Si el gestor de paquetes está mal configurado y consulta también el registro público, un atacante que suba un acme-auth al registro público con un número de versión más alto puede conseguir que tu build descargue el suyo en lugar del interno. Alex Birsan demostró esto en 2021 contra decenas de grandes tecnológicas.

    2.3 Cuenta de mantenedor comprometida

    Phishing al mantenedor, un token de publicación filtrado en un commit, o una cuenta sin 2FA. El atacante publica una versión nueva del paquete real, con su nombre real y su reputación real. Los lockfiles que solo fijan la versión (no el hash) y las políticas de actualización automática propagan el paquete envenenado en horas.

    2.4 Build troyanizado

    El más difícil de detectar: el código fuente en el repositorio público está limpio. La puerta trasera se inyecta durante la compilación —en xz vivía en unos archivos de test binarios y en un script de ./configure ofuscado que solo se activaba al construir el paquete .deb/.rpm, nunca desde el repositorio git. Por eso auditar solo el fuente no basta: hace falta que el binario sea reproducible y que su origen sea verificable.

    3. SBOM: saber qué llevas dentro

    Un SBOM (Software Bill of Materials, lista de materiales de software) es el inventario completo de componentes de un artefacto: nombre, versión, identificador único (purl), licencia, hashes y relaciones entre ellos. Los dos formatos estándar son CycloneDX (OWASP) y SPDX (Linux Foundation, norma ISO/IEC 5962). Se genera automáticamente en el pipeline con herramientas como Syft, Trivy, cdxgen o el propio `npm sbom`.

    Para qué sirve de verdad: cuando mañana se publica un CVE crítico en una librería, un SBOM guardado te responde en minutos —no en días— a la pregunta «¿está esto en alguno de mis productos, y en qué versión?». Es lo que faltó en muchas organizaciones durante Log4Shell (diciembre de 2021), que pasaron una semana solo averiguando dónde tenían Log4j.

    Para qué no sirve: un SBOM no te protege por sí mismo, no dice si una dependencia es explotable en tu contexto (para eso está el análisis VEX, que anota «este CVE no aplica porque no llamamos a esa función») y no vale de nada si se genera y se tira. El valor está en almacenarlo por cada versión publicada y poder consultarlo históricamente.

    # Generar un SBOM en formato CycloneDX de una imagen de contenedor
    syft registry.ejemplo.com/miapp:1.4.2 -o cyclonedx-json > sbom-miapp-1.4.2.json
     
    # Generar un SBOM de un proyecto Node y de uno Python
    npm sbom --sbom-format cyclonedx > sbom.json
    cyclonedx-py environment -o sbom.json
     
    # Cruzar un SBOM ya guardado contra la base de vulnerabilidades OSV
    osv-scanner scan --sbom sbom-miapp-1.4.2.json

    4. Fijar lo que descargas: versiones y hashes

    Instalar con rangos abiertos (^1.2.0, >=2.0) significa que dos builds del mismo commit en dos días distintos pueden traer código diferente. La primera capa de defensa es hacer el build determinista.

    • Lockfiles: package-lock.json, yarn.lock, poetry.lock, Cargo.lock, go.sum. Fijan la versión exacta de todo el árbol, incluidas las transitivas. Deben estar versionados en git y revisarse en cada PR que los toque.
    • Hashes, no solo versiones: pip admite `–require-hashes` con el digest SHA-256 de cada paquete; npm guarda un campo `integrity` en el lockfile; Go usa go.sum. Si el hash no cuadra, el build falla —una versión republicada con el mismo número no cuela.
    • Instalación reproducible en CI: usar `npm ci` (no `npm install`), `pip install –require-hashes -r requirements.txt`, `poetry install –sync`. Fallan si el lockfile no está sincronizado, que es justo lo que quieres.
    • Fijar GitHub Actions por SHA, no por etiqueta: `uses: actions/checkout@<sha-completo>` en lugar de `@v4`, porque una etiqueta se puede mover a un commit malicioso.
    • Fijar imágenes base por digest: `FROM debian:12@sha256:…` en lugar de `FROM debian:12`.
    # requirements.txt con hashes: pip rechaza cualquier cosa que no cuadre
    requests==2.32.3 \
        --hash=sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6
     
    pip install --require-hashes --no-deps -r requirements.txt
     
    # Generar ese fichero con hashes a partir de tu entorno
    pip-compile --generate-hashes requirements.in

    5. Firma y procedencia: de dónde viene este binario

    Fijar hashes garantiza que descargas lo mismo que ayer, pero no que ese algo sea legítimo. Para eso hace falta una cadena verificable entre el código fuente, el sistema de build y el artefacto final.

    5.1 Sigstore y cosign

    Sigstore hace la firma de artefactos sin que el desarrollador gestione claves privadas de larga duración. Usa firma sin clave (keyless): se obtiene un certificado efímero ligado a una identidad OIDC (la cuenta de GitHub Actions, por ejemplo), se firma en esos pocos minutos, y la firma queda registrada en un log público de transparencia (Rekor) que es append-only y auditable, igual que Certificate Transparency para los certificados TLS. `cosign` es la herramienta de línea de comandos.

    # Firmar una imagen desde CI (identidad = el propio workflow de GitHub Actions)
    cosign sign registry.ejemplo.com/miapp:1.4.2
     
    # Verificar antes de desplegar: exige QUIEN firmo y DESDE QUE workflow
    cosign verify registry.ejemplo.com/miapp:1.4.2 \
      --certificate-identity=https://github.com/miorg/miapp/.github/workflows/release.yml@refs/heads/main \
      --certificate-oidc-issuer=https://token.actions.githubusercontent.com

    5.2 Procedencia SLSA

    SLSA (Supply-chain Levels for Software Artifacts) es un marco de niveles que describe cuánta garantía tienes sobre cómo se construyó un artefacto. Su pieza central es la atestación de procedencia: un documento firmado, generado por el propio sistema de build, que dice qué fuente (commit exacto), qué builder y qué parámetros produjeron este binario. Los niveles van de L1 (procedencia existe) a L3 (build aislado y procedencia infalsificable). npm provenance (`npm publish –provenance`) publica esta atestación automáticamente cuando el paquete se construye en un CI compatible, y npmjs.com muestra el enlace al commit y al workflow de origen.

    El objetivo práctico: una política de admisión

    El destino de todo esto es un control automático en el punto de despliegue —un admission controller de Kubernetes (Sigstore Policy Controller, Kyverno), una regla en el pipeline— que rechace cualquier artefacto sin firma válida y sin procedencia del repositorio y el workflow esperados. Sin ese «portero», firmar es solo ceremonia.

    6. Análisis continuo de dependencias

    El inventario y la firma no detectan que una de tus 800 dependencias tiene un CVE publicado la semana pasada. Eso lo hace el análisis de composición de software (SCA), que cruza tu árbol de dependencias contra bases de vulnerabilidades.

    HerramientaQué haceDónde encaja
    osv-scannerCLI de Google que consulta la base OSV.dev; lee lockfiles y SBOMLocal y en CI, gratis, sin cuenta
    DependabotAlertas + PRs automáticos de actualización en GitHubRepos en GitHub, configuración mínima
    RenovateComo Dependabot pero multiplataforma y muy configurable (agrupado, ventanas)GitLab, Bitbucket, self-hosted
    Trivy / GrypeEscáner de imágenes y filesystems; también genera SBOMPipeline de contenedores
    npm audit / pip-auditAuditoría rápida del ecosistema concretoComprobación de andar por casa
    • Ejecuta el escáner en cada PR (que falle el check si entra una vulnerabilidad crítica nueva) y también en cron sobre la rama principal, porque aparecen CVE en código que ya tenías.
    • Prioriza con contexto: un CVE crítico en una dependencia de desarrollo que no llega a producción no es lo mismo que uno en una librería expuesta a internet. EPSS y la lista KEV de CISA ayudan a ordenar.
    • Vigila la antigüedad y el mantenimiento de las dependencias, no solo los CVE: un paquete sin commits en tres años con un único mantenedor es deuda de seguridad aunque hoy no tenga fallos conocidos.
    • Reduce el árbol: cada dependencia que eliminas es superficie que desaparece. Desconfía de las librerías de una sola función.

    7. Una hoja de ruta razonable

    FaseAcciónEsfuerzo
    1Lockfiles versionados + `npm ci` / `pip –require-hashes` en CIBajo
    2SCA (osv-scanner o Dependabot) bloqueando PRs con CVE críticoBajo
    3Generar y archivar un SBOM por cada versión publicadaMedio
    4Fijar Actions por SHA e imágenes base por digestMedio
    5Firma con cosign + npm provenance / atestación SLSA en el releaseMedio
    6Política de admisión que verifica firma y procedencia antes de desplegarAlto
    7Registro interno espejo (proxy) para no depender del registro público en cada buildAlto

    Errores frecuentes al implantar esto

    Generar SBOM y no guardarlos: el valor es histórico, no del momento · Firmar sin verificar: si nadie comprueba la firma en el despliegue, la firma no aporta seguridad · Fijar por etiqueta creyendo que es fijar (las etiquetas de git y de contenedor son móviles; usa SHA y digest) · Actualización automática sin revisión humana de los cambios en el lockfile en dependencias sensibles · Ignorar el postinstall: los scripts de instalación de npm se ejecutan en tu máquina y en tu CI; considera `–ignore-scripts` y listas de permitidos

    Uso responsable y marco legal

    Las herramientas y técnicas de este artículo son para auditar y proteger software propio o sobre el que tienes autorización expresa · Publicar paquetes maliciosos, registrar nombres para typosquatting o alterar artefactos de terceros constituye delito —en España, arts. 197 bis, 197 ter, 248 y ss. y 264 del Código Penal, además de la responsabilidad civil correspondiente · Si descubres una dependencia comprometida o un paquete malicioso, sigue divulgación responsable: avisa al mantenedor y al registro (npm security, PyPI, GitHub Security Advisories) y, si procede, al INCIBE-CERT; no lo difundas con pruebas de concepto funcionales antes del parche

    Conclusión

    La cadena de suministro es la superficie de ataque que menos controlas y más ha crecido: tu producto es, en peso, mayoritariamente código que no escribiste. SolarWinds y xz no fueron accidentes raros, fueron demostraciones de que atacar la confianza escala mucho mejor que atacar el perímetro.

    La buena noticia es que las defensas se pueden implantar por capas y las primeras son baratas: lockfiles con hashes, un escáner de dependencias que bloquee lo crítico, y un SBOM archivado por release ya te dejan en mejor posición que la media. Firma, procedencia y política de admisión son el siguiente escalón, y hoy —con Sigstore y las atestaciones SLSA integradas en los CI— están al alcance de cualquier equipo, no solo de las grandes.

    Referencias

    SLSA — slsa.dev (marco de niveles y plantillas de procedencia) · Sigstore — sigstore.dev · docs de cosign y del log Rekor · OWASP CycloneDX — cyclonedx.org · SPDX — spdx.dev · OSV — osv.dev y osv-scanner (github.com/google/osv-scanner) · CISA/NSA — Securing the Software Supply Chain (guías para desarrolladores y para consumidores) · NIST SSDF (SP 800-218) — prácticas de desarrollo seguro

    unfantasmaenelsistema.com | Seguridad, sistemas y todo lo que no debería funcionar (pero funciona)

    Resumen de privacidad

    Esta web utiliza cookies para que podamos ofrecerte la mejor experiencia de usuario posible. La información de las cookies se almacena en tu navegador y realiza funciones tales como reconocerte cuando vuelves a nuestra web o ayudar a nuestro equipo a comprender qué secciones de la web encuentras más interesantes y útiles.