Saltar al contenido

npm audit no es suficiente: cómo controlar tus dependencias de npm

En la práctica/ 12 min de lectura

Qué ve y qué no ve npm audit, y lo que falta: lockfile, revisar dependencias con npm view, actualizar por pasos y aprobar scripts de instalación en npm 12.

  • Node.js
  • Seguridad
  • JavaScript
En este artículo (8)
  1. Qué ve y qué no ve npm audit
  2. Fijar versiones con el lockfile
  3. Revisar una dependencia antes de agregarla
  4. Actualizar poco a poco
  5. Leer los scripts de instalación (npm 12 los bloquea)
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

npm audit solo compara las versiones de tu árbol de dependencias con avisos de seguridad ya publicados. No ve un paquete malicioso que todavía no tiene aviso, un script de instalación que ya corrió ni una librería abandonada. Para cubrir eso: commitea el lockfile, revisa cada dependencia antes de agregarla, actualiza poco a poco y controla los scripts de instalación.

Todo lo de abajo lo corrimos el 19 de noviembre de 2026 en un proyecto de prueba, con npm 12.2.3 y npm 11 sobre Node 22. Desde npm 12.0.0, publicado el 8 de julio de 2026, los scripts de instalación de las dependencias ya no corren hasta que los apruebas; más abajo está cómo funciona.

Qué ve y qué no ve npm audit

Según la documentación de npm audit, el comando envía a tu registro una descripción de las dependencias de tu proyecto (nombres y versiones) y pide un reporte de vulnerabilidades conocidas. Los enlaces del reporte apuntan a la base de avisos de GitHub. Es una consulta contra una lista: si la versión que tienes instalada cae en el rango de un aviso, aparece; si no hay aviso, no aparece. Así se ve en un proyecto con una sola dependencia directa, express@4.17.1, una versión vieja que elegimos a propósito (salida recortada):

$ npm audit
# npm audit report

qs  <=6.16.0
Severity: high
qs vulnerable to Prototype Pollution - https://github.com/advisories/GHSA-hrpp-h998-j3pp
...
fix available via `npm audit fix`
node_modules/qs

7 vulnerabilities (3 low, 4 high)

To address all issues, run:
  npm audit fix
  1. qs <=6.16.0 es el paquete y el rango afectado. Tú nunca instalaste qs: llega a través de express y body-parser.
  2. Severity: high y el enlace al aviso GHSA-…, que explica el fallo y la versión corregida.
  3. fix available via npm audit fix significa que hay una versión corregida dentro de los rangos de tu package.json.
  4. El resumen cuenta siete paquetes vulnerables: body-parser, cookie, path-to-regexp, qs, send, serve-static y el propio express, que depende de ellos.

Eso es útil y conviene correrlo. El problema es lo que no ve:

  • Lo que todavía no tiene aviso. Si alguien publica una versión maliciosa de un paquete que usas, npm audit no dirá nada hasta que exista el aviso. Esa ventana es justo cuando se instala.
  • El orden. La auditoría corre al final de npm install, después de que los scripts de instalación de las dependencias ya corrieron (en npm 11 y anteriores, que los ejecutan sin preguntar).
  • El mantenimiento. Un paquete sin cambios en años, con una sola cuenta que publica, o deprecado, no es una vulnerabilidad conocida.
  • El tamaño del árbol. Audit no te dice que una línea en tu package.json trajo 50 paquetes.
  • Lo que no está en el lockfile: lo que bajas con npx, herramientas globales, scripts de un CDN o código copiado a mano.

Y al revés: reporta una vulnerabilidad aunque tu código nunca use la parte afectada. --audit-level=high solo cambia a partir de qué gravedad el comando sale con error; la documentación aclara que no filtra el reporte.

lo que npm audit reporta y lo que nonpm audit lo veversión con aviso publicadodependencias transitivasrango afectado y versión corregidasi hay fix dentro de tu rangonpm audit no lo veversión maliciosa sin aviso aúnscript de instalación que ya corriópaquete abandonado o deprecadocuántos paquetes trae una líneanpx, globales, CDN, código copiadofound 0 vulnerabilities = sin avisos conocidosuna consulta contra una listafuente: documentación de npm audit (v12)

Desliza la figura para verla completa

Riesgo¿Lo ve npm audit?Qué lo cubre
Versión con un aviso publicadoSínpm audit, actualizar
Versión maliciosa sin aviso todavíaNoLockfile, npm ci, esperar unos días antes de adoptar versiones nuevas
Script de instalación que corre códigoNoallowScripts en npm 12, revisar hasInstallScript
Paquete abandonado o deprecadoNonpm view antes de agregarlo
Árbol enorme por una sola dependenciaNonpm ls --all, instalar de prueba
Vulnerabilidad en código que no usasSí, igual la reportaLeer el aviso y decidir

Fijar versiones con el lockfile

Cuando instalas express@4.17.1, npm guarda en package.json el rango ^4.17.1, que acepta cualquier 4.x posterior. Lo que fija la versión exacta es package-lock.json: según su documentación, describe el árbol exacto que se generó para que las siguientes instalaciones produzcan el mismo, y está pensado para commitearse. Esta es la entrada de express en el lockfile del proyecto de prueba:

"node_modules/express": {
  "version": "4.17.1",
  "resolved": "https://registry.npmjs.org/express/-/express-4.17.1.tgz",
  "integrity": "sha512-mHJ9O79RqluphRrcw2X/GTh3k9tVv8YcoyY4Kkh4WDMUYKRZUq0h1o0w2rrrxBqM7VoeUVqgb27xlEMXTnYt4g==",
  ...
}
  1. La clave es la ruta dentro de node_modules: el lockfile guarda todo el árbol, no solo tus dependencias directas.
  2. version es la versión exacta instalada, aunque el rango permita otras.
  3. resolved dice de dónde se descargó el paquete.
  4. integrity es el hash del archivo descargado. Si el contenido cambia, la instalación falla en vez de instalar otra cosa.

Con el lockfile commiteado, npm install mantuvo 4.17.1 aunque ya existía 4.22.3 dentro del rango. Para servidores y CI, usa npm ci: según su documentación, exige un lockfile, sale con error si no coincide con package.json en vez de modificarlo, borra node_modules antes de instalar y nunca escribe en ninguno de los dos archivos. Así lo que se despliega es exactamente lo que probaste. Si construyes una imagen, el mismo npm ci va en la etapa de dependencias del Dockerfile multi-stage.

una línea en package.json, 50 paquetes instaladosdemo-store (tu proyecto)npm auditexpress@4.17.1altabody-parser@1.19.0altacookie@0.4.0bajapath-to-regexp@0.1.7altasend@0.17.1bajaserve-static@1.14.1bajaqs@6.7.0alta1dependencia directa50paquetes instalados65con express@5.3.0los avisos estaban en transitivassalida real de npm ls y npm audit, 19 nov 2026

Desliza la figura para verla completa

Revisar una dependencia antes de agregarla

La mejor dependencia es la que no agregas. Si la necesitas, revisa tres cosas antes del npm install: quién la mantiene, cuándo se publicó la última versión y cuántos paquetes trae. npm view consulta el registro público sin instalar nada:

$ npm view express dist-tags.latest time.modified repository.url
dist-tags.latest = '5.3.0'
time.modified = '2026-11-07T17:35:30.254Z'
repository.url = 'git+https://github.com/expressjs/express.git'

$ npm view express maintainers
$ npm view request deprecated
request has been deprecated, see https://github.com/request/request/issues/3142

$ npm view esbuild scripts
{ postinstall: 'node install.js' }
  1. dist-tags.latest es la versión que instala npm install express sin número.
  2. time.modified es la última vez que cambió el paquete en el registro. Años sin cambios no es malo por sí solo, pero sumado a avisos abiertos es una señal de alerta.
  3. repository.url te lleva al código. Si no hay repositorio, no puedes leer lo que instalas.
  4. maintainers lista las cuentas que pueden publicar. Una sola cuenta es un único punto de falla.
  5. deprecated devuelve el mensaje de deprecación, o nada si el paquete no lo está.
  6. scripts muestra si la versión actual tiene postinstall u otros scripts que corren al instalar.

Para saber cuántos paquetes trae, instálala de prueba en una carpeta vacía con npm install express --package-lock-only (solo escribe el lockfile) y cuenta con npm ls --all --parseable. Lo medimos: express@5.3.0 trae 65 paquetes en total y express@4.17.1, 50. npm ls sin --all solo muestra tus dependencias directas, y npm explain qs responde por qué está instalado un paquete que no pediste:

$ npm explain qs
qs@6.7.0
node_modules/qs
  qs@"6.7.0" from body-parser@1.19.0
  node_modules/body-parser
    body-parser@"1.19.0" from express@4.17.1
    node_modules/express
      express@"^4.17.1" from the root project

Así encontramos en el artículo sobre la RCE de Next.js 14 qué versión de sharp cargaba Next: la vulnerabilidad estaba en una dependencia que nadie había agregado a mano.

revisar una dependencia antes de agregarlapreguntacomandoseñal de alertaquién publicanpm view pkg maintainersuna sola cuentaúltima versiónnpm view pkg time.modifiedaños sin cambios y avisoscódigo fuentenpm view pkg repository.urlsin repositoriodeprecadonpm view pkg deprecateddevuelve un mensajescriptsnpm view pkg scriptspreinstall o postinstallcuántas traenpm ls --all --parseabledecenas para algo pequeñonpm view lee el registro público sin instalar nadaquién, cuándo, cuántascomandos probados con npm 12.2.3, 19 nov 2026

Desliza la figura para verla completa

Actualizar poco a poco

npm outdated compara lo instalado con lo que permite tu rango y con la última versión. Sale con código 1 si hay algo desactualizado:

$ npm outdated
Package  Current  Wanted  Latest  Location              Depended by
express   4.17.1  4.22.3   5.3.0  node_modules/express  demo-store

$ npm update express
added 18 packages, changed 23 packages, and audited 69 packages in 2s
found 0 vulnerabilities
  1. Current es lo instalado; Wanted, lo más nuevo que acepta tu rango ^4.17.1; Latest, la última publicada, que aquí es una versión mayor.
  2. npm update express subió a 4.22.3, dentro del rango, y la auditoría quedó en cero. También agregó 18 paquetes: actualizar cambia el árbol, por eso se revisa.
  3. Pasar a 5.3.0 es un cambio mayor: va solo, con las notas de la versión leídas y tus pruebas corriendo.

Una dependencia por commit, pruebas entre cada una y el lockfile en el mismo commit. Si algo se rompe, sabes qué fue y lo reviertes sin arrastrar lo demás. Evita npm audit fix --force como reflejo: la documentación advierte que puede instalar versiones fuera de tu rango, incluidos cambios mayores.

Para no ser de los primeros en instalar una versión recién publicada, npm tiene min-release-age (en días; documentación de configuración). Con --min-release-age=60, npm install express eligió 5.2.1 en vez de 5.3.0, publicada el 9 de octubre de 2026; lo probamos en npm 12.2.3 y 11.11.1. Un parche de seguridad urgente es la excepción: ahí actualizas ya, como explicamos con los parches de Next.js de noviembre. Y no olvides el runtime: npm 12 pide Node ^22.22.2 || ^24.15.0 || >=26.0.0, y en cómo actualizar Node en Docker está el proceso.

Leer los scripts de instalación (npm 12 los bloquea)

Un paquete puede declarar preinstall, install o postinstall, y esos comandos corren en tu máquina o en tu servidor al instalarlo, con tus permisos. Es la vía clásica de los paquetes maliciosos, y corre antes de que npm audit tenga algo que decir.

Las notas de npm 12.0.0 lo cambian: los scripts de las dependencias quedan bloqueados por defecto salvo que el campo allowScripts del package.json raíz los permita. Según la documentación de npm install-scripts, el bloqueo cubre preinstall, install, postinstall y, para dependencias que no vienen del registro, prepare. Los scripts de tu propio proyecto siguen corriendo. Esto vimos con npm 12.2.3:

$ npm install esbuild@0.25.0
added 2 packages, and audited 3 packages in 2s
found 0 vulnerabilities
npm warn install-scripts 1 package had install scripts blocked because they are not covered by allowScripts:
npm warn install-scripts   esbuild@0.25.0 (postinstall: node install.js)

$ npm install-scripts approve esbuild
Approved esbuild:
  added esbuild@0.25.0

$ npm rebuild
rebuilt dependencies successfully
  1. La instalación termina bien y npm audit dice found 0 vulnerabilities, pero el postinstall de esbuild no corrió.
  2. El aviso dice qué paquete y qué comando quedaron bloqueados. npm install-scripts ls lista los pendientes.
  3. approve escribe en package.json la entrada "allowScripts": { "esbuild@0.25.0": true }, fijada a esa versión.
  4. npm rebuild corre los scripts recién aprobados.

Como la aprobación queda fijada a la versión, cuando subimos a esbuild 0.25.1 el script volvió a quedar bloqueado hasta aprobarlo otra vez: cada versión nueva pasa por tu revisión. npm install-scripts deny esbuild guarda "esbuild": false para todas las versiones y ya no avisa. Muchos paquetes funcionan sin su script; en nuestra prueba, esbuild 0.28.2 siguió transformando TypeScript con el script denegado. No todos: un módulo nativo que compila al instalar lo necesita. Lee el script (npm view <paquete> scripts) y decide.

En CI, pon strict-allow-scripts=true en el .npmrc del proyecto: una dependencia con scripts sin revisar hace fallar npm ci con ESTRICTALLOWSCRIPTS en vez de solo avisar. Pasar --allow-scripts en una instalación de proyecto es un error; ese flag es para instalaciones globales y npx.

Si sigues en npm 11, los scripts corren. npm 11.21.3 avisa ("not yet covered by allowScripts") pero los ejecuta, y ya tiene npm install-scripts approve, así que puedes dejar la lista lista antes de subir a npm 12; npm 11.11.1 los corrió sin avisar. Para ver qué paquetes de tu lockfile tienen scripts en cualquier versión, este script lee el campo hasInstallScript:

// list-install-scripts.mjs: dependencies in package-lock.json that run code when installed
import { readFileSync } from "node:fs";

const lock = JSON.parse(readFileSync("package-lock.json", "utf8"));
let count = 0;

for (const [path, pkg] of Object.entries(lock.packages ?? {})) {
  if (path === "" || !pkg.hasInstallScript) continue;
  const i = path.lastIndexOf("node_modules/");
  const name = i === -1 ? path : path.slice(i + "node_modules/".length);
  console.log(name + "@" + pkg.version + "  " + (pkg.resolved ?? "(no resolved URL)"));
  count++;
}
console.log(count + " package(s) with install scripts");
  1. Lee package-lock.json de la carpeta actual. Necesita un lockfile versión 2 o 3 (npm 7 en adelante), que tiene el objeto packages.
  2. Recorre cada entrada; la clave vacía "" es tu propio proyecto y se salta.
  3. hasInstallScript es el campo que npm marca cuando el paquete tiene preinstall, install o postinstall.
  4. El nombre sale de la última node_modules/ de la ruta, así funcionan los paquetes con scope (@scope/nombre) y los anidados; un workspace se imprime con su ruta.
  5. Imprime nombre, versión y origen, y al final el total.

En el proyecto de prueba imprimió esbuild@0.28.2 https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz y 1 package(s) with install scripts. Corre el script antes y después de cada actualización: si aparece un paquete nuevo en la lista, léelo antes de aprobarlo.

Errores comunes

  • Tomar "found 0 vulnerabilities" como un visto bueno. Solo significa que no hay avisos publicados para esas versiones.
  • No commitear package-lock.json. Cada instalación puede resolver versiones distintas y el servidor no corre lo que probaste.
  • Usar npm install en CI. Puede reescribir el lockfile; npm ci falla si no coincide.
  • Correr npm audit fix --force sin leer. Puede meter cambios mayores en tu árbol.
  • Actualizar todo de una vez. Si algo se rompe, no sabes qué fue.
  • Aprobar todos los scripts con --all para quitar el aviso. Vuelves al comportamiento de npm 11.
  • Revisar solo tus dependencias directas. La mayoría de los avisos del ejemplo estaban en paquetes que nadie agregó a mano.

Preguntas frecuentes

¿npm audit detecta paquetes maliciosos?

Solo cuando ya existe un aviso. La base de avisos de GitHub incluye avisos de malware, pero mientras nadie lo haya reportado, la versión maliciosa pasa la auditoría. Por eso importan el lockfile, esperar antes de adoptar versiones nuevas y bloquear los scripts.

¿Tengo que pasar a npm 12 para bloquear los scripts?

Es lo más directo, porque npm 12 los bloquea por defecto. En npm 11 corren; puedes usar --ignore-scripts, que apaga todos, incluidos los de tu proyecto, o preparar allowScripts con npm install-scripts approve en las versiones de npm 11 que ya lo traen.

¿Por qué npm install-scripts deny me da ENOMATCH?

El comando trabaja sobre lo instalado: si el paquete no está en node_modules, no encuentra a quién aplicarlo. Instala primero sin modo estricto, luego aprueba o deniega, y después activa strict-allow-scripts.

¿Cada cuánto actualizo dependencias?

Revisa npm outdated y npm audit con una frecuencia fija, por ejemplo cada semana, y aplica los parches de seguridad en cuanto salen. Las versiones mayores van una a una, con tiempo para probarlas.

Checklist

  • package-lock.json está commiteado y CI instala con npm ci.
  • npm audit --audit-level=high corre en CI y lees los avisos que reporta.
  • Antes de agregar una dependencia revisas npm view: versión, fecha, repositorio, cuentas que publican, deprecación y scripts.
  • Sabes cuántos paquetes trae con npm ls --all.
  • Actualizas una dependencia por commit, con pruebas, y las mayores por separado.
  • Usas min-release-age o esperas unos días antes de adoptar versiones nuevas, salvo parches de seguridad.
  • En npm 12, allowScripts solo tiene paquetes que revisaste y strict-allow-scripts=true está en el .npmrc.
  • En npm 11, sabes qué paquetes tienen scripts y los revisas en cada actualización.

Ninguna de estas medidas reemplaza a las otras: npm audit cubre lo conocido, el lockfile y npm ci cubren lo que se instala, y la revisión cubre lo que entra a tu proyecto.

¿Viste esto en Instagram? Comenta DEPENDENCIAS en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 19 de noviembre de 2026

← Blog