Principales conclusiones
- Cuando una corrección solo se incluye en una versión más reciente, al actualizar para obtenerla se descargan todas las demás.
- La retrocompatibilidad solo aplica la corrección a la versión que utilizas, lo que a menudo te ahorra tener que realizar la migración.
- El «pinning» permite que los cambios sean predecibles y sigue siendo válido mientras la versión fijada siga recibiendo correcciones.
- La cobertura no debería terminar cuando un paquete llega al final de su ciclo de vida, ya que las vulnerabilidades (CVE) registradas para él no lo hacen.
Todos los desarrolladores conocen este ticket. El escáner se pone en rojo un martes, el aviso indica que la corrección se ha incluido en la versión 5.0.0 y tú estás utilizando la 3.8. La solución sugerida ocupa una sola línea. El trabajo real es una carrera de velocidad.
Los equipos pierden semanas con esto, y lo frustrante es que, a menudo, la vulnerabilidad no es lo más complicado. Muchas correcciones de CVE consisten en unas pocas líneas de código. Lo que las encarece es todo lo que viene con esas líneas cuando la única forma oficial de obtenerlas es actualizar el sistema.
Entonces, ¿se puede solucionar una vulnerabilidad sin actualizar a una nueva versión principal? A menudo, sí. Pero conviene entender por qué «basta con actualizar» se ha convertido en la respuesta por defecto y en qué casos deja de funcionar.
Por qué la actualización se convirtió en la respuesta por defecto
Durante la mayor parte de la historia del software libre, la corrección de vulnerabilidades ha seguido el mismo ciclo. Alguien informa de una vulnerabilidad, un responsable de mantenimiento la corrige en la rama principal, se publica una nueva versión y todos los usuarios posteriores actualizan su versión. Muchas herramientas de análisis de dependencias se basan en ese ciclo. Comparan la versión que tienes con las versiones que se sabe que contienen la corrección y te indican que la actualices.
Esto funciona bien cuando la diferencia es pequeña. Pasar de la versión 2.4.1 a la 2.4.2 suele ser algo sin importancia. El problema es que los mantenedores corrigen los errores en las ramas en las que están trabajando activamente, que suelen ser la rama principal más reciente y quizá una o dos ramas LTS. Muy pocos proyectos disponen del tiempo o del personal necesarios para volver atrás y aplicar parches a una versión de hace dos años, y nadie puede esperar razonablemente que los voluntarios lo hagan. Por lo tanto, cuanto más te alejes de la versión actual, más se convierte una «simple actualización» en una migración.
Cuando la solución viene incluida con todo lo demás
A esto lo denomino «corrección vinculada a una versión». Se trata de un parche de seguridad que el desarrollador original solo incluye en una versión más reciente, por lo que la única forma oficial de obtener la corrección es aceptar todos los demás cambios que esa versión conlleva.
Es en esos otros cambios donde reside el verdadero coste. Una nueva versión principal podría dejar de ser compatible con el entorno de ejecución que utilizas, cambiar el nombre de una API a la que tu código recurre en cuarenta lugares, invertir un valor por defecto en el que confiabas o traer consigo su propio conjunto de dependencias transitivas. Se supone que el versionado semántico te avisa de todo eso, y lo hace cuando los mantenedores lo respetan. Pero los cambios que rompen la compatibilidad aparecen con tanta frecuencia en las versiones menores que nadie debería considerar un número de versión como una promesa. E incluso una versión principal perfectamente documentada tiene que ser leída, probada e implementada por alguien, normalmente alguien que tenía otros planes para esa semana.
npm es bastante claro al respecto. Cuando npm audit fix Si no puede resolver algo dentro de los rangos de versiones que has declarado, normalmente te indicará que npm audit fix --force, que la documentación de npm Se puede describir como una opción que permite instalaciones fuera del rango especificado, incluidos los cambios de versión mayor según SemVer. Tampoco te preguntará para cuál de esos saltos de versión mayor estás realmente preparado. Es algo perfectamente razonable para un proyecto de fin de semana. En un servicio de producción, es el primer paso hacia una búsqueda de regresiones.
Tres aspectos en los que la actualización falla
Lo primero resulta obvio una vez que te topas con ello. A veces ni siquiera hay una versión fija a la que migrar. El paquete ha quedado obsoleto o la línea de versiones ha llegado al final de su ciclo de vida, y ya nadie va a volver a utilizarlo. El request El paquete es el ejemplo clásico de Node. Aunque quedó obsoleto a principios de 2020, sigue apareciendo en muchos árboles de dependencias, y cuando 28155, una vulnerabilidad que permite que las redirecciones entre protocolos eludan las protecciones contra SSRF, se dio a conocer en 2023, pero el paquete original no recibió ninguna versión corregida. Y sigue sin recibirla. Una bifurcación mantenida, @cypress/request, sí que lanzó una corrección, pero se incluyó en la versión 3.0.0 con un nombre de paquete diferente, y cambiar de paquete supone una migración en sí misma.
El segundo es el gran salto de versión. La corrección existe, pero está en la versión 6.x, mientras que tú utilizas la 4.x, y pasar de una a otra implica modificar código de la aplicación que no tiene nada que ver con la vulnerabilidad. Tu equipo de seguridad quiere que se cierre el CVE esta semana. Tu jefe de ingeniería sabe que la migración podría llevarse todo un trimestre. Ambos tienen razón, y esa es precisamente la razón por la que estas incidencias permanecen abiertas durante tanto tiempo, y por la que una incidencia que comenzó como una corrección de seguridad a veces acaba teniendo su propio documento de diseño.
El tercero pilla a la gente por sorpresa, y se trata de la dependencia transitiva. El paquete vulnerable no está en tu package.json en absoluto. Está cuatro niveles más abajo, incorporada por un proyecto padre cuyo rango de versiones no permite la versión corregida. La opción más limpia es actualizar el proyecto padre, si una versión más reciente del mismo permite la versión corregida, ya que así te mantienes dentro del rango que los propios mantenedores del proyecto padre eligieron. Sin embargo, si esa versión está a una versión principal de distancia, vuelves al segundo problema. La otra opción es forzar la versión con Anulaciones de npm. Yarn los llama resolutions, y las versiones actuales de pnpm establecen overrides en pnpm-workspace.yaml. Las sustituciones funcionan, pero te obligan a utilizar una combinación que los responsables del proyecto original nunca han probado, por lo que esa tarea de probarla recae sobre ti. Y si la versión corregida es una versión principal superior a la que espera el proyecto original, la sustitución le está proporcionando al proyecto original una API para la que nunca se diseñó.
El problema nunca fue el «pinning»
Hay un consejo que se repite mucho, y es que fijar las dependencias congela las vulnerabilidades. Técnicamente, eso es cierto. Fija una versión, no la toques nunca más, y todas las CVE que se publiquen sobre ella te seguirán afectando.
Sin embargo, creo que ese enfoque culpa a lo que no debe. El «pinning», junto con un archivo de bloqueo fijo y unas instalaciones que lo respeten, garantiza que el entorno de producción ejecute el árbol de dependencias que realmente has probado. Además, evita que una versión recién secuestrada se cuele en tu compilación en la siguiente instalación, y tras los últimos años de cuentas de mantenedores comprometidas, eso es importante. En septiembre de 2025, se utilizó una cuenta de mantenedor suplantada para publicar versiones maliciosas de chalk y debug a npm. Los equipos que realicen la instalación mediante npm ci A partir de un archivo de bloqueo limpio, confirmado antes del ataque, se siguió compilando con las versiones que ya habían comprobado. Los equipos que dejan que todo se actualice a la versión más reciente están cambiando un tipo de riesgo por otro.
El verdadero problema es qué ocurre con la línea de versiones que has fijado. Una versión fijada nunca incorpora correcciones por sí sola, por lo que dependes de que alguien publique una versión parcheada para esa línea. Una vez que el desarrollador original deja de hacerlo, lo más probable es que te veas obligado a elegir entre convivir con la vulnerabilidad CVE —quizá con una medida de mitigación— o llevar a cabo la migración. Si se soluciona eso, la fijación volverá a ser lo que se pretendía que fuera: una forma de controlar el cambio en lugar de una forma de acumular riesgos.
En qué consiste realmente el backporting
El «backporting» consiste en adaptar una corrección de seguridad de una versión más reciente de un paquete a una versión anterior, de modo que la versión que ya utilizas reciba la corrección sin el resto de los cambios introducidos en el código original. Las distribuciones de Linux llevan décadas haciendo esto. Cuando Red Hat lanza una corrección para una versión antigua de OpenSSL, se trata de un «backport», y nadie espera que los clientes de RHEL se pasen a la última versión del código original cada vez que se publica un CVE.
Hacer lo mismo con las dependencias de la aplicación parece bastante sencillo. Buscar el commit del código original, aplicarlo a la etiqueta antigua y publicarlo. En la práctica, el commit a menudo no se aplica sin problemas. El código circundante se ha movido, las firmas de las funciones han cambiado y, a veces, la corrección se basa en una refactorización que tuvo lugar tres versiones después de la versión a la que se está aplicando el parche. El parche podría llamar a una función auxiliar que aún no existe en la línea de código anterior, o validar los datos de entrada en una capa que el código antiguo nunca tuvo. Por lo tanto, quien realice la adaptación hacia atrás debe comprender cuál es realmente la vulnerabilidad, no solo cómo se ve la diferencia entre los códigos, y escribir una corrección que cierre el mismo agujero en el código anterior.
A continuación, hay que demostrarlo. Una buena adaptación a versiones anteriores se recompila a partir del código fuente, se ejecuta con el conjunto de pruebas del propio proyecto —si existe— y se comprueba frente a la propia vulnerabilidad para confirmar que el agujero se ha cerrado. El objetivo es que no cambie nada, salvo aquello que la corrección está destinada a cambiar. A veces, una corrección de seguridad tiene que endurecer algún aspecto del que dependía tu código, como rechazar entradas que la versión anterior aceptaba sin avisar, y cuando eso ocurre, debe indicarse claramente, no introducirse de forma encubierta. Todo lo demás debería comportarse igual que ayer.
No voy a fingir que esto funciona para todas las CVE. Algunas correcciones están ligadas a cambios arquitectónicos que simplemente no existen en el código antiguo, y eso es algo que le pasa a cualquiera que se dedique a este trabajo. Sin embargo, muchas vulnerabilidades son mucho más localizadas que eso. Una comprobación de límites que falta, una expresión regular que retrocede mal, una entrada que nunca se validó. A menudo, estos problemas se pueden corregir en el código antiguo sin tener que arrastrar la arquitectura más reciente, y son la razón por la que corregir vulnerabilidades sin actualizar funciona tan a menudo como lo hace.
Cómo corrige SecureChain las vulnerabilidades sin necesidad de actualizar
Este es el problema que hemos creado SecureChain en general. SecureChain ofrece versiones parcheadas desde un registro npm gestionado por TuxCare. Una versión parcheada parte de la misma versión original, añade la corrección y obtiene un -tuxcare.N sufijo al final, así que 3.8.0 se convierte en 3.8.0-tuxcare.1. Un proyecto en la versión 3.8 sigue en la 3.8, ahora con la corrección.
Ese sufijo hace que sea una cadena de versión diferente, y un rango como ^3.8.0 No lo detectará por sí solo. Por eso, la CLI de SecureChain se encarga de la asignación. securechain sca analiza el árbol de dependencias resuelto e informa de los elementos vulnerables, incluidos los paquetes que se pueden corregir con una versión parcheada. securechain harden A continuación, fija esas compilaciones, escribe modificaciones (o resoluciones de Yarn) para los paquetes transitivos, actualiza el archivo de bloqueo y vuelve a instalar. Antes de finalizar, comprueba que el árbol de instalación contenga realmente las nuevas compilaciones y, si no puede confirmarlo, restaura los archivos a su estado anterior. Añade --dry-run si quieres ver el cambio antes de que se escriba nada.
Tu archivo de bloqueo cambia, al igual que el paquete parcheado, pero el código de tu aplicación no suele tener que cambiar, y no has pasado a una nueva versión principal. Seguirías ejecutando tus pruebas antes del lanzamiento, igual que con cualquier actualización de dependencias. En la integración continua (CI), securechain check el proceso falla si existe una versión parcheada y el proyecto no la está utilizando, para que nadie vuelva a utilizar la versión vulnerable por error. La interfaz de línea de comandos (CLI) es compatible con npm, pnpm y Yarn.
¿Qué ocurre cuando el desarrollador principal deja de publicar correcciones?
El «backporting» se encarga de la corrección vinculada a una versión concreta. Sin embargo, por sí solo, no resuelve el problema del paquete que el desarrollador original ha dejado de mantener. Muchos paquetes quedan en el olvido mucho antes de que nadie declare oficialmente su fin de vida útil.
SecureChain aborda esto por etapas, tal y como se detalla en la documentación de SecureChain. Mientras el proyecto original siga publicando correcciones, el plazo de respuesta comienza a contar a partir de la corrección del proyecto original. Si el proyecto original deja de publicarlas y el paquete entra en una etapa denominada «Sustained», TuxCare se hace cargo directamente de su mantenimiento, y los tiempos de respuesta se cuentan a partir del día en que se publica el CVE, no a partir de una corrección del proyecto original que quizá nunca llegue. En el caso de un CVE crítico, TuxCare tiene como objetivo lanzar una versión parcheada en un plazo de 7 días desde la corrección del desarrollador original en la primera fase y en un plazo de 14 días desde la publicación una vez que ha asumido el mantenimiento. A partir de ahí, el paquete pasa a la «Asistencia de ciclo de vida ilimitado» (ELS) y, si ha contratado ELS junto con SecureChain, la aplicación de parches continúa desde ese momento durante todo el tiempo que necesite el paquete.
Recuerda request? Upstream nunca publicó una corrección para CVE-2023-28155, pero los datos VEX publicados por TuxCare la marcan como resuelta en request 2.88.2-tuxcare.2 y todas las compilaciones posteriores. La línea de versión es la misma, no hay que cambiar el nombre de nada en tu package.json, y no hay ninguna rama a la que migrar.
Lo que me gusta de esta configuración es que, con ambos elementos en su sitio, no hay ningún vacío. Nadie de tu equipo tiene por qué darse cuenta de que un responsable del mantenimiento ha dejado de dar señales de vida, y nadie tiene que salir corriendo a buscar un nuevo proveedor. Sigues descargando una nueva versión parcheada del mismo modo que harías con cualquier actualización, y el registro del que procede sigue siendo el mismo, tanto si el responsable original está ocupado con el lanzamiento, ha dejado de dar señales de vida o se ha marchado por completo.
Cuándo conviene actualizar de todos modos
Nada de esto es un argumento en contra de actualizar. Las nuevas versiones principales aportan mejoras de rendimiento, mejores API y correcciones para un montón de errores para los que nadie ha presentado nunca un CVE. Planifica esas actualizaciones y llévalas a cabo.
La discusión gira en torno a quién establece el calendario. Cuando la única forma de corregir una vulnerabilidad CVE es actualizar el sistema, es la propia vulnerabilidad la que dicta tu hoja de ruta. Cuando puedes aplicar un parche a la versión que tienes instalada, actualizas porque la nueva versión merece la pena, la pruebas adecuadamente y lo haces en el plazo que ha elegido tu equipo. Esa es una razón mucho mejor para modificar una dependencia que una alerta roja en un escáner.
Preguntas frecuentes
¿Se puede solucionar una vulnerabilidad sin actualizar el paquete?
A menudo, sí. Cuando el código vulnerable es bastante autónomo, la corrección se puede aplicar retroactivamente a la versión que ya utilizas, lo que soluciona la vulnerabilidad sin los cambios que pueden provocar incompatibilidades, las nuevas dependencias o el trabajo de migración que suelen conllevar las versiones principales más recientes.
¿Cómo se aplica una corrección retroactiva en npm, pnpm o Yarn?
Instala la versión parcheada de la que ya dispones. En el caso de los paquetes transitivos, fíjalos mediante anulaciones en npm o pnpm, o mediante resoluciones en Yarn. Las versiones parcheadas suelen llevar un sufijo como, por ejemplo, -tuxcare.1, algo que tus rangos de versiones actuales no pueden igualar por sí mismos, por lo que la sustitución es lo que permite que la compilación se incorpore al árbol, mientras que la versión principal se mantiene en la línea de versiones prevista.
¿Es seguro forzar la corrección de «npm audit»?
Correr npm audit fix --force Puede eliminar las advertencias, pero lo hace permitiendo que npm instale versiones fuera de los rangos que has declarado, incluidas las versiones principales según SemVer, y algunas de ellas conllevarán cambios que pueden provocar incompatibilidades. Trátalo como una actualización que no habías previsto. Revisa los cambios que se han producido en el archivo de bloqueo y ejecuta tu conjunto completo de pruebas antes de que nada de esto llegue al entorno de producción.
¿Qué es una corrección de seguridad retroaplicada?
Una corrección de seguridad retrocompatible es un parche adaptado a partir de una versión más reciente de un paquete y aplicado a una versión anterior. Su alcance se limita a la vulnerabilidad y excluye los cambios no relacionados, por lo que el código escrito para la versión anterior debería seguir funcionando, aunque es recomendable probarlo como cualquier otra actualización de dependencias.
¿Qué significa que una corrección de seguridad esté vinculada a una versión más reciente?
Esto significa que la corrección está vinculada a una versión concreta. Una corrección vinculada a una versión es un parche de seguridad que el desarrollador original solo incluye en una versión más reciente, por lo que aplicarla mediante una actualización implica aceptar también todos los demás cambios de esa versión; así es como la resolución de un CVE se convierte en una migración completa.
¿Es seguro fijar las versiones de las dependencias?
El «pinning», junto con un archivo de bloqueo definido e instalaciones que lo respeten, como por ejemplo npm ci, es una buena práctica porque te permite reproducir el árbol de dependencias que has probado y evita que las versiones no revisadas se incluyan en tus compilaciones. El riesgo radica en dejar la versión fijada sin parches, por lo que la fijación funciona mejor cuando esa versión sigue recibiendo correcciones de seguridad.
¿Cómo se soluciona una vulnerabilidad en una dependencia transitiva?
Las opciones habituales son actualizar el paquete principal, si una versión más reciente admite la versión corregida, o forzar la versión corregida mediante sustituciones, lo que puede provocar errores en el paquete principal. Una compilación adaptada te ofrece una tercera opción, ya que la sustitución puede apuntar a una compilación parcheada basada en la misma versión de origen que ya utiliza el paquete principal.
¿Qué ocurre con la seguridad de un paquete una vez que llega al final de su vida útil?
Upstream deja de publicar correcciones, pero siguen registrándose nuevas CVE relacionadas con él. A menos que alguien siga aplicando parches, solo te quedan las medidas de mitigación, una bifurcación o una migración, y, mientras tanto, las vulnerabilidades siguen sin solucionarse.
