SSD Nodes Learn Hosting plans →
Guías Matt ConnorPor Matt Connor · Actualizado 2026-10-22

Ataques a la cadena de suministro de npm en su servidor

Descubra cómo un parche malicioso, un script postinstall o un typosquat llega a su app Node en un VPS y qué práctica de despliegue evita instalar versiones comprometidas.

Qué es un ataque a la cadena de suministro de npm en su servidor

Un ataque a la cadena de suministro de npm llega a su servidor a través de un paquete que usted decidió instalar. No interviene ningún puerto abierto ni una fase de explotación. npm instala código, y al instalar código se ejecuta código. Por eso, una aplicación Node pequeña puede incorporar varios cientos de paquetes que nunca ha revisado, y cualquiera de ellos puede publicar una versión nueva una hora después.

Su despliegue obtiene una versión maliciosa porque el comando de instalación solicitó la versión más reciente que coincidiera con el rango indicado. Ese código se ejecuta con los privilegios de quien haya ejecutado la instalación. Todo lo que sigue se deriva de esas dos frases.

Los casos se ordenan según la frecuencia con la que afectan a una persona que despliega una aplicación Node en un único VPS. Ese orden no sería el que usaría una empresa grande, porque una empresa grande tiene un registro interno, un equipo de revisión y un espejo del registro público. Usted tiene un script de despliegue.

Forma 1: una cuenta de mantenedor es comprometida y publica un parche

El registro de npm no permite cambiar el contenido de una versión que ya existe. Por tanto, un atacante que suplanta a un mantenedor mediante phishing o roba un token de publicación no puede reescribir 4.18.2. Publica 4.18.3.

Revise su package.json. Una línea como "express": "^4.18.2" no significa la versión 4.18.2. El carácter de intercalación significa «cualquier versión 4.x igual o posterior a esta», y ~4.18.2 significa «cualquier versión 4.18.x». npm install resuelve ese rango en el momento de la ejecución, por lo que el mismo commit de git, desplegado dos veces durante la misma tarde, puede instalar dos conjuntos de código diferentes. Esa diferencia es la superficie de ataque. Para que aparezca no es necesario comprometer nada en su máquina.

Las versiones maliciosas suelen notificarse y retirarse, pero la retirada ocurre después de que algunas personas las hayan instalado. Quien haya desplegado durante ese intervalo tiene el código en el disco. Una canalización que resuelve rangos en cada ejecución entra automáticamente en ese intervalo varias veces por semana, sin que nadie tenga que decidirlo.

Forma 2: un script de instalación se ejecuta como el usuario que realiza el despliegue

El package.json de un paquete puede declarar preinstall, install, postinstall y prepare en su bloque scripts. npm los ejecuta durante la instalación. No se ejecutan en un entorno aislado y nadie los revisa. Son comandos de shell que se ejecutan como el usuario que introdujo el comando de instalación, en el directorio personal de ese usuario, con su acceso de red y el entorno completo de ese shell.

npm 12, publicado el 8 de julio de 2026, cambia ese comportamiento predeterminado: bloquea los scripts de instalación de dependencias, salvo que el campo allowScripts del proyecto los autorice en package.json. A fecha de 12 de octubre de 2026, ninguna versión de Node.js incluye npm 12 (Node.js 26.11.1 incluye npm 11.20.0). Por tanto, si no actualizó npm manualmente, la versión de npm del servidor sigue ejecutando todos esos scripts.

Por tanto, la pregunta útil no es qué puede hacer el paquete. Es qué puede leer ese usuario. En un equipo de despliegue normal, la respuesta incluye ~/.npmrc, que contiene un token del registro, ~/.ssh/id_ed25519, que se usa como clave de despliegue para SSH (secure shell), ~/.aws/credentials, ~/.docker/config.json y todas las variables exportadas en el shell. Ahí suele estar DATABASE_URL.

Una carga útil como esta no necesita persistencia ni escalada de privilegios. Lee algunos archivos, los envía a un host mediante HTTPS y termina con el estado 0. No verá nada porque npm oculta de forma predeterminada la salida de los scripts de instalación. Desactive esa opción y observe lo que se ejecuta realmente:

npm ci --foreground-scripts

foreground-scripts comparte la entrada, la salida y el error estándar con el proceso de npm. Por tanto, los scripts de compilación imprimen su salida en el terminal en lugar de hacerlo en un búfer que npm descarta cuando la instalación finaliza correctamente.

Forma 3: typosquatting y el nombre que no escribió exactamente

Un typosquat es un paquete publicado con un nombre parecido al de otro popular. Espera a que alguien escriba mal o pegue incorrectamente un comando de instalación. El mecanismo es el comando, no el código. Por eso, un lockfile no ayuda en este caso: se añade el nombre incorrecto una vez y, a partir de entonces, el lockfile lo fija correctamente.

La variante que afecta a los equipos y no sólo a usuarios individuales es la confusión de dependencias. El paquete interno se llama billing-utils y se encuentra en un registro privado. Si no existe ningún paquete llamado billing-utils en el registro público, cualquiera puede publicar uno. npm resuelve los nombres sin ámbito contra el registro público predeterminado, por lo que puede ganar la copia pública. La solución consiste en usar un ámbito propio y una asignación de registro para ese ámbito, en .npmrc:

@yourorg:registry=https://npm.yourorg.example/
//npm.yourorg.example/:_authToken=${NPM_TOKEN}

Ahora @yourorg/billing-utils sólo se obtiene de ese host, porque la asignación de ámbito a registro se consulta antes que el registro predeterminado. Un nombre interno sin ámbito no tiene ninguna asignación, por lo que no está protegido.

Antes de añadir una dependencia nueva, revísela en lugar de fijarse en su contador de descargas:

npm view some-lib repository.url maintainers time.created time.modified

Un paquete creado el mes pasado y publicado por una cuenta que no puede vincular a un repositorio público supone un riesgo distinto al de otro con seis años de historial. Ninguno de estos datos constituye una prueba. Ambos se pueden comprobar rápidamente.

Forma 4: la dependencia cuyo propietario cambió sin avisar

Los mantenedores transfieren los paquetes. Alguien se agota, otra persona se ofrece a ayudar, cambian los permisos de publicación y ningún aviso llega a los proyectos que dependen de ese paquete. No se ha producido ninguna intrusión. La confianza que depositó en 2021 ahora está en manos de otra persona.

Esta es la forma más lenta y difícil de detectar. Ningún comando responde directamente a esta cuestión. Hay dos medidas que ayudan a acotarla. Compruebe quién puede publicar antes de adoptar un paquete, con la línea npm view anterior. Después, lea el diff cuando cambie un paquete del que realmente dependa:

npm diff --diff-name-only --diff=some-lib@1.4.2 --diff=some-lib@1.4.3
npm diff --diff=some-lib@1.4.2 --diff=some-lib@1.4.3

La primera forma muestra sólo los nombres de los archivos modificados. Es suficientemente rápida para ejecutarla en cada actualización de un paquete importante. Conviene leer completo cualquier parche que modifique un script de compilación, añada un archivo en la raíz del paquete o edite el bloque scripts antes de que llegue a su servidor.

Compilar a partir de un lockfile confirmado con npm ci

package-lock.json registra la versión exacta de cada paquete del árbol, la URL de la que procede, un hash de integridad sha512 de cada tarball y el paquete que lo requiere. Confírmelo en el repositorio. Es el único archivo que indica qué se probó realmente.

Después, instale con npm ci, nunca con npm install, en cualquier máquina que no sea el portátil de un desarrollador:

npm ci --omit=dev --ignore-scripts

npm ci difiere de npm install en aspectos relevantes. Requiere que exista un lockfile. Elimina cualquier node_modules existente antes de empezar, de modo que los restos de un despliegue anterior no puedan persistir en este despliegue. Nunca escribe en package.json ni en el lockfile, por lo que una instalación no puede avanzar de versión silenciosamente. Si el lockfile y package.json no coinciden, termina con un error en lugar de resolver la diferencia.

Ese error es una característica, no una molestia. Significa que un cambio de dependencia debe llegar como un commit revisado por otra persona y no como un efecto secundario de un despliegue a las 02:00.

El hash de integridad se comprueba en cada descarga. Si los bytes de un tarball no coinciden con el hash registrado, la instalación termina con code EINTEGRITY en lugar de desempaquetarlo. Hay que precisar qué garantiza esto: demuestra que el archivo recibido es el archivo fijado por el lockfile, la misma garantía que ofrece verificar descargas con checksums, y tiene la misma limitación. No indica si la versión fijada era maliciosa cuando se publicó.

Un detalle sobre --omit=dev: esos paquetes siguen resolviéndose y siguen escribiéndose en el lockfile. Simplemente no se colocan en el disco. Tener menos paquetes en el disco implica menos scripts de instalación y menos código cargado en tiempo de ejecución, por lo que conviene hacerlo. No elimina una dependencia del árbol.

Trate los scripts de instalación como código y sepa cuándo rechazarlos

Puede desactivar los scripts de instalación. Añada esto al .npmrc del proyecto y confirme el cambio junto al lockfile:

ignore-scripts=true
save-exact=true

ignore-scripts=true impide que npm ejecute los scripts declarados en las dependencias. save-exact=true hace que npm install some-lib escriba 1.4.2 en package.json en lugar de ^1.4.2, para que un rango de versiones no entre por accidente en el manifiesto.

Esto rompe algunas cosas, y debe saber cómo resolverlas antes de activarlo. Los paquetes que compilan un complemento nativo o descargan un binario precompilado realizan ese trabajo en un script de instalación. Con los scripts desactivados, la instalación termina correctamente, pero el fallo aparece después, en tiempo de ejecución, cuando un módulo no puede cargar su archivo de enlace. La solución es una lista de permitidos:

npm ci --ignore-scripts
npm rebuild better-sqlite3 --ignore-scripts=false

npm rebuild <package> ejecuta los scripts de compilación de ese paquete. --ignore-scripts=false no es opcional: npm rebuild respeta el ignore-scripts=true que acaba de confirmar en .npmrc y, sin la anulación, enlaza los binarios del paquete sin ejecutar ninguno de sus scripts. Así toma una decisión para cada paquete, en lugar de conceder permisos de ejecución generales a cientos de desconocidos que nunca conocerá.

Si ejecuta npm 12, esta lista de permitidos está integrada. npm approve-scripts better-sqlite3 registra la aprobación en el campo allowScripts de package.json, omite con una advertencia los scripts de dependencias no aprobados y npm rebuild comprueba la misma lista, por lo que en npm 12 la reconstrucción anterior también necesita esa aprobación. Un ignore-scripts=true confirmado anula por completo la política de allowScripts.

Para comprobar el alcance actual de esa concesión, consulte npm:

npm query ":attr(scripts, [postinstall])"

Esto muestra todos los paquetes del árbol instalado que contienen un script postinstall. En una aplicación típica, la lista es más corta de lo que se espera, y precisamente por eso la lista de permitidos resulta práctica.

Separar la compilación del proceso que atiende el tráfico

El usuario de despliegue necesita escribir en node_modules. El proceso que responde a las peticiones HTTP no. Si ambos usan la misma cuenta, el código que se ejecuta durante la instalación puede modificar el código que atiende a los usuarios. El código que se ejecuta durante el tiempo de ejecución también puede hacerlo.

Sepárelos. Compile con un usuario, atienda las peticiones con otro y haga que el directorio servido sea de solo lectura para la cuenta que atiende las peticiones:

sudo useradd --system --home-dir /srv/nodeapp --shell /usr/sbin/nologin nodeapp
sudo chown -R deploy:nodeapp /srv/nodeapp
sudo chmod -R o-rwx /srv/nodeapp

Después, deje que systemd lo haga cumplir. Escriba /etc/systemd/system/nodeapp.service:

[Unit]
Description=Node application
After=network-online.target

[Service]
User=nodeapp
Group=nodeapp
WorkingDirectory=/srv/nodeapp/current
EnvironmentFile=/etc/nodeapp/env
ExecStart=/usr/bin/node server.js
Restart=on-failure

NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
ReadWritePaths=/srv/nodeapp/shared
NoExecPaths=/srv/nodeapp/shared
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX

[Install]
WantedBy=multi-user.target

ProtectSystem=strict monta todo el sistema de archivos como de solo lectura para este servicio, excepto /dev, /proc, /sys y todo lo que indique en ReadWritePaths. Por tanto, un intento de la aplicación de escribir en node_modules falla con EROFS: read-only file system. Puede comprobarlo y reproducirlo en sus propios registros en aproximadamente un minuto. NoExecPaths cubre el directorio de carga de archivos, que debe ser escribible: el servicio puede escribir allí, pero el kernel rechaza su ejecución. Esta opción requiere systemd 248 o posterior, y Ubuntu 24.04 incluye la versión 255.

Hay dos problemas frecuentes en este archivo de unidad. Primero, no añada MemoryDenyWriteExecute=yes. Aparece en la mayoría de las listas de endurecimiento de systemd y evita que Node se inicie, porque V8 compila JavaScript a código máquina durante el tiempo de ejecución y necesita páginas que sean escribibles y ejecutables al mismo tiempo. Segundo, obtenga la ruta de ExecStart desde command -v node. Si Node se instaló con un gestor de versiones, se encuentra en el directorio personal del usuario de despliegue. ProtectHome=yes oculta después ese directorio al servicio y la unidad falla inmediatamente con status=203/EXEC, junto con una línea de registro que indica que no se pudo localizar el ejecutable.

Compruebe el resultado en lugar de confiar únicamente en el archivo:

sudo systemctl daemon-reload
sudo systemctl enable --now nodeapp
sudo systemd-analyze security nodeapp.service
sudo -u nodeapp touch /srv/nodeapp/current/probe

systemd-analyze security muestra todos los ajustes de endurecimiento y su nivel de exposición, para que pueda ver cuáles siguen con el valor predeterminado. touch debería fallar con Permission denied, porque nodeapp no es propietario de ningún archivo bajo current. Si se ejecuta correctamente, la propiedad de los archivos es incorrecta y la configuración de systemd lo está ocultando de forma silenciosa.

Una observación sobre EnvironmentFile: systemd lo lee como root antes de cambiar a User=nodeapp, por lo que ese archivo puede tener el propietario root:root y el modo 600. La aplicación sigue recibiendo las variables. Cualquier persona con una shell como nodeapp puede leerlas desde /proc/<pid>/environ, por lo que esto protege el secreto almacenado, pero no el proceso en ejecución.

Mantenga las credenciales de despliegue fuera del entorno de compilación

Los scripts de instalación heredan el entorno. Este hecho debe determinar dónde compila.

La opción más segura es compilar en un equipo que no sea el servidor de producción y copiar allí el directorio terminado. El equipo de compilación sólo conserva un token de registro de solo lectura. No contiene ninguna otra credencial: ni una clave de despliegue SSH, ni una clave de acceso a la nube, ni una contraseña de base de datos, ni credenciales para iniciar sesión en un registro de contenedores.

npm token create --name=build-readonly --packages-and-scopes-permission=read-only --packages-all --expires=30

Un token de solo lectura puede descargar paquetes, pero no puede publicarlos. npm revocó todos los tokens clásicos el 9 de diciembre de 2025, por lo que se trata de un token de acceso granular. El indicador de permisos es lo que lo hace de solo lectura: el npm actual todavía acepta el indicador antiguo --read-only, pero npm token create no lo envía al registro. Si alguien roba el token del entorno de compilación, la pérdida se limita al acceso de lectura a los paquetes que cubre.

Si debe compilar en el servidor, compile como el usuario deploy con un entorno deliberadamente limitado. Mantenga los secretos de ejecución en /etc/nodeapp/env, que deploy no puede leer. El mismo razonamiento se aplica a la automatización de compilaciones que aloja usted mismo: un runner de GitHub Actions autohospedado conserva tokens y ejecuta código publicado arbitrario en cada trabajo, por lo que es la máquina de mayor valor en un despliegue pequeño. Cualquier programa que no haya escrito usted y que reciba todo el entorno pertenece a la misma categoría. Por eso, mantener los secretos fuera del entorno de un agente de IA plantea este mismo problema con otro programa interpuesto.

Fije una versión o incluya el paquete cuyo código no pueda auditar

Una dependencia fijada es aquella cuya versión no puede cambiar sin un commit. El lockfile versionado ya hace eso para todo el árbol. Hay dos casos que requieren medidas adicionales.

Las dependencias transitivas son el primero. Usted no controla de qué dependen sus dependencias. overrides en package.json obliga a usar una versión en cualquier punto del árbol:

{
  "overrides": {
    "some-transitive-lib": "1.4.2"
  }
}

Ejecute npm install una vez después de añadirlo para que el lockfile registre el resultado y, después, confirme ambos archivos.

El segundo caso es un paquete que no puede auditar y que tampoco puede eliminar. Inclúyalo en su repositorio. npm pack descarga el tarball exacto que serviría el registro, y una dependencia file: se instala desde su copia:

npm pack some-lib@1.4.2
mkdir -p vendor && mv some-lib-1.4.2.tgz vendor/
{
  "dependencies": {
    "some-lib": "file:vendor/some-lib-1.4.2.tgz"
  }
}

El tarball ahora está en su repositorio y no puede cambiar sin que usted lo modifique. También ha asumido para siempre la responsabilidad de actualizarlo. Use esta opción para el paquete pequeño y abandonado del que no puede prescindir, no para su framework web.

También existe un periodo de espera que no cuesta nada:

npm install --before=2026-08-01

La opción before reconstruye el árbol usando sólo versiones publicadas en esa fecha o antes. Retroceda una o dos semanas al actualizar las dependencias. Así evita el periodo en el que una versión defectuosa está disponible y todavía no se ha informado de ella. Es una medida general, porque también retrasa correcciones de seguridad legítimas. Úsela para resolver los rangos, revise los cambios y, después, confirme el lockfile. Las versiones recientes de npm también aceptan min-release-age, una ventana móvil expresada en días (min-release-age=7 en .npmrc), que hace lo mismo sin tener que actualizar una fecha. Conviene aplicar el mismo criterio a las herramientas de línea de comandos que instala desde npm en lugar de declararlas como dependencias: una llamada npx sin versión fijada descarga lo que se haya publicado esa mañana, mientras que fijar una versión exacta de dsh garantiza que dos máquinas ejecuten el mismo código.

¿Cómo sé qué versión se publicó realmente?

El lockfile de git indica qué debería haberse instalado. El disco indica qué está instalado. Sólo el segundo aporta pruebas.

npm ls some-lib
node -e "console.log(require('./node_modules/some-lib/package.json').version)"

npm ls lee node_modules, por lo que informa de lo que está presente físicamente y no de lo que pretendía el lockfile. La línea node -e lee el manifiesto instalado mediante su ruta. Esto también funciona con paquetes cuyo campo exports impide las importaciones de subrutas. Además, muestra una sola versión sin dibujar un árbol alrededor.

Para la otra parte de la comparación, lea git:

git log --oneline -- package-lock.json
git show <commit>:package-lock.json | grep -A3 '"node_modules/some-lib"'

Haga permanente la relación entre ambos elementos incluyendo el commit en la estructura de despliegue. Publique en /srv/nodeapp/releases/<short commit sha> y apunte /srv/nodeapp/current hacia él mediante un enlace simbólico. La respuesta a «qué se está ejecutando ahora mismo» pasa a ser readlink /srv/nodeapp/current. Además, queda disponible a las 03:00 para alguien que no fue quien lo desplegó.

Por último, compruebe qué puede garantizar el registro:

npm audit signatures

Esto verifica las firmas del registro en los paquetes del árbol instalado. También verifica las atestaciones de procedencia de los paquetes que las tienen. La procedencia vincula un tarball publicado con la compilación pública de integración continua (CI) que lo produjo. Por tanto, una atestación verificada permite rastrear el código hasta un commit y no hasta un portátil desconocido. La cobertura no es universal. Interprete una atestación ausente como «sin información», no como «paquete defectuoso».

Qué hacer después de que una versión defectuosa llegue al servidor

Empiece por lo que se ejecutó y por el usuario con el que se ejecutó.

Si el código se ejecutó durante la instalación, suponga que todo lo que el usuario de compilación podía leer ya está comprometido. Rote el token del registro, las claves SSH del directorio personal de ese usuario, las credenciales de la nube y cualquier secreto exportado en ese shell. La rotación es la única respuesta correcta, porque no puede demostrar que un archivo no se leyera.

Si el código se ejecutó en tiempo de ejecución con una cuenta de servicio restringida, el conjunto accesible es mucho menor: las variables de entorno de la aplicación y todo aquello al alcance de su acceso de red. Ese es el motivo para ejecutar servicios como usuarios sin privilegios en un VPS. Esto no impide la intrusión. Determina qué parte de la máquina queda expuesta y si la intrusión sobrevive a un reinicio.

Después, vuelva a crear el entorno en lugar de limpiarlo. Elimine node_modules, fije el paquete afectado a una versión anterior a la versión defectuosa en package.json, ejecute npm install una vez para actualizar el archivo de bloqueo, haga commit y despliegue con npm ci. No repare el árbol en el mismo lugar. No puede enumerar todo lo que modificó un script de instalación.

Anote también la ventana temporal: el primer despliegue que podría haber descargado la versión y el despliegue que la eliminó. Ese intervalo indica qué registros propios debe revisar, y sólo puede determinarlo si las versiones se identifican mediante commits.

Qué no soluciona nada de esto

Un lockfile no hace segura una dependencia. Convierte el momento en que aceptó esa dependencia en una decisión fechada y revisada, en lugar de dejarlo como un efecto secundario de un despliegue. Todas las prácticas anteriores realizan la misma conversión: transforman un accidente en una elección.

npm audit no es una defensa en este caso. Compara su árbol con una base de datos de vulnerabilidades notificadas, por lo que detecta problemas que ya se han publicado y cuyo nombre ya se conoce. Un ataque a la cadena de suministro permanece sin nombre durante toda su vida útil. Ejecute npm audit para detectar errores antiguos y conocidos, pero no espere que le informe de un release publicado hace cuatro horas.

Reducir el número de dependencias ayuda más que cualquier herramienta de esta guía, y es el consejo menos popular. Cada paquete que no añade es un editor más que no puede sufrir phishing en su nombre y un script de instalación más que nunca se ejecutará con el usuario de despliegue.

Nada de esto es exclusivo de npm. Las mismas cuatro formas se aplican a PyPI, RubyGems, imágenes de contenedor y el gestor de paquetes de su distribución. En npm se ve con más frecuencia porque los árboles son más profundos y porque el npm que ejecutan la mayoría de los servidores sigue ejecutando scripts de instalación de forma predeterminada. Todo lo que amplía una herramienta que ya ejecuta hereda el mismo problema. Por eso determinar a qué puede acceder un plugin de dsh antes de instalarlo es el mismo ejercicio que leer un script de postinstall, pero con los permisos de su agente en lugar de los del usuario de despliegue. La parte de la máquina circundante que debe proteger depende de dónde se ejecute. Esto forma parte de la cuestión más amplia de si el alojamiento VPS es seguro.

FAQ

¿npm ci me protege frente a un paquete de npm comprometido?

Te protege frente a cambios de versión que se produzcan sin tu conocimiento. npm ci instala exactamente lo que registra package-lock.json, comprueba cada tarball con su hash de integridad sha512 y termina con un error si package.json y el archivo de bloqueo no coinciden, en lugar de resolver la diferencia. No indica si la versión fijada es segura. Si confirmas un archivo de bloqueo que fija una versión maliciosa, npm ci instalará fielmente esa versión en todos tus servidores, siempre.

¿Debo configurar ignore-scripts=true para todo?

Configúralo y después crea una lista de permitidos. ignore-scripts=true en el .npmrc del proyecto impide que se ejecuten los scripts de instalación de las dependencias. Esto elimina la vía más directa entre un paquete malicioso y las credenciales del usuario de despliegue. Los paquetes que compilan un addon nativo o descargan un binario precompilado realmente necesitan sus scripts. Con los scripts desactivados, fallan más adelante, durante la ejecución, porque falta el archivo de binding, en lugar de fallar durante la instalación. Ejecuta npm ci --ignore-scripts y después npm rebuild <package> --ignore-scripts=false para los pocos paquetes en los que hayas decidido confiar, porque, de lo contrario, npm rebuild respeta la configuración de .npmrc y no ejecuta ningún script. npm query ":attr(scripts, [postinstall])" muestra cuántos paquetes necesitan realmente esta excepción.

¿Cómo puedo saber qué versión de un paquete instaló realmente mi servidor?

Lee el disco, no el archivo de bloqueo. npm ls <package> informa de lo que está presente en node_modules, y node -e "console.log(require('./node_modules/<package>/package.json').version)" imprime sólo la cadena de versión. El archivo de bloqueo del repositorio git responde a otra pregunta: qué debería haberse instalado. Comparar ambos valores es precisamente el objetivo. Desplegar en un directorio cuyo nombre corresponde al commit de git conserva ambas respuestas para consultarlas meses después, cuando las necesites.

¿npm audit detecta ataques a la cadena de suministro?

No. npm audit compara tu árbol de dependencias con una base de datos de vulnerabilidades notificadas. Por tanto, sólo detecta problemas que ya se hayan publicado y hayan recibido un identificador. Una versión maliciosa no está registrada durante las horas o los días en los que su instalación resulta relevante. npm audit signatures es el comando más útil: verifica las firmas del registro en todo el árbol instalado y comprueba las atestaciones de procedencia cuando el editor las haya generado. Esto indica si un tarball procede de una compilación pública y no de una máquina desconocida.

¿Por qué importa ejecutar la aplicación con un usuario sin privilegios si el ataque ocurre durante la instalación?

Porque ambos fallos tienen un alcance distinto y debes protegerte frente a los dos. El código que se ejecuta durante la instalación lo hace como el usuario de despliegue y puede leer sus claves SSH, tokens del registro y credenciales de servicios cloud. El código que se ejecuta durante el funcionamiento usa la cuenta del servicio. Con User=nodeapp, ProtectSystem=strict y sin credenciales en el disco, su alcance se limita al entorno propio de la aplicación y a su base de datos. Separar las cuentas también impide que el proceso que atiende el tráfico sobrescriba node_modules. Así, un compromiso durante la ejecución desaparece en el siguiente reinicio en lugar de hacerse permanente.

¿Te resultó útil este artículo?