Un paquete oficial convertido en ladrón de credenciales
El 17 de noviembre de 2026 aparecieron en PyPI, el índice público de paquetes de Python, dos versiones maliciosas de agent-framework, la biblioteca que Microsoft distribuye para construir agentes de inteligencia artificial. Se trata de las versiones 1.26.1 y 1.26.2. Ambas incluían código diseñado para robar credenciales de entornos de Azure y de sistemas de integración continua, y ambas fueron retiradas del índice en menos de una hora. La última versión limpia conocida es la 1.26.0.
Lo que convierte este incidente en un caso de estudio es el mecanismo elegido por los atacantes. En lugar de esconder el código dañino dentro de una función que se ejecuta cuando alguien importa la biblioteca, lo colocaron en un archivo con extensión .pth, un tipo de fichero que el intérprete de Python procesa cada vez que arranca. Eso significa que un entorno que instaló cualquiera de las dos versiones quedó expuesto aunque ningún programa llegara a importar el paquete, e incluso aunque el desarrollador solo ejecutara una orden trivial de Python.
El paquete cuenta con una audiencia considerable: se estima que ronda las 190.000 a 200.000 descargas mensuales. A fecha de redacción, ningún actor ha sido señalado de forma confirmada como responsable. No es el único episodio reciente: ya analizamos cómo una clave robada de Fireworks AI permitió colar malware en Cursor, y para entender qué hay detrás de estos marcos puedes leer cómo funcionan los agentes de IA. También es útil el repaso de la intrusión en Hugging Face y la demanda a OpenAI.
Este artículo repasa qué se sabe con certeza, cómo funciona la técnica, qué diferencia a este ataque de otros del mismo tipo y, sobre todo, qué medidas prácticas conviene aplicar para reducir el riesgo y para responder si se sospecha que un entorno quedó afectado.
Qué es agent-framework y por qué importa
Agent-framework es un marco de trabajo orientado a la creación de agentes y flujos de trabajo con modelos de lenguaje. Está publicado por Microsoft y se instala, como la mayoría de bibliotecas del ecosistema Python, con el gestor pip desde el índice público. Su perfil lo sitúa en una zona especialmente delicada: quienes lo usan suelen trabajar en entornos que ya tienen acceso a servicios en la nube, a modelos alojados, a repositorios de código y a tuberías de despliegue.
Ese contexto es clave para entender el valor del objetivo. Un desarrollador que experimenta con agentes de IA normalmente dispone de variables de entorno con claves de acceso, sesiones abiertas con la línea de comandos de Azure, tokens para plataformas de código y secretos de las herramientas que orquestan pruebas y despliegues. Comprometer una biblioteca de esta categoría equivale a colocarse a la puerta de una sala donde se guardan muchas llaves a la vez.
Las cifras de uso refuerzan la importancia del incidente. Con cerca de doscientas mil descargas al mes, incluso una ventana de exposición breve puede traducirse en un número apreciable de instalaciones. Hay que recordar, además, que las descargas mensuales no equivalen a usuarios únicos: una parte importante procede de sistemas automáticos, espejos y tuberías de integración continua que reinstalan dependencias en cada ejecución. Precisamente esos sistemas, que instalan sin intervención humana la versión más reciente permitida, son los más propensos a incorporar una versión envenenada en cuestión de minutos.
Cronología de los hechos
Los datos confirmados permiten reconstruir una secuencia sencilla. El 17 de noviembre de 2026 se publicó la versión 1.26.1, que incorporaba el código malicioso. Poco después se publicó la 1.26.2, con variaciones respecto a la primera. Las dos fueron retiradas del índice en menos de una hora desde su aparición, según indican los análisis publicados por varias firmas de seguridad. La versión 1.26.0, anterior a ambas, se considera limpia.
Un detalle relevante de esa cronología es que la segunda versión apareció cuando la primera ya había sido puesta en cuarentena. Esto sugiere que quien actuaba conservaba la capacidad de publicar en el proyecto incluso después de la primera reacción, lo cual apunta a que el problema no se resolvía con eliminar una única versión, sino que exigía revocar el acceso que permitía publicar. Es una lección que se repite en incidentes de este tipo: retirar el artefacto malicioso es necesario, pero no basta si la credencial que lo hizo posible sigue siendo válida.
También conviene señalar un hecho que los analistas destacaron: no se encontró en el repositorio oficial de código del proyecto una etiqueta o lanzamiento que correspondiera a la versión 1.26.1. Esa ausencia indica que la publicación probablemente no salió del proceso habitual de lanzamiento del proyecto, sino de una subida directa al índice. Es un indicio técnico, no una conclusión sobre el origen de la intrusión, y no debe leerse como una atribución.
La ventana total de exposición fue corta, pero en distribución de software una hora puede ser suficiente. Cualquier máquina o tubería que ejecutara una instalación o actualización en ese intervalo, sin versión fijada, pudo descargar el contenido dañino. Quien instaló antes de la publicación o después de la retirada no recibió esas versiones, aunque la única forma fiable de saberlo es comprobar qué quedó instalado realmente en cada entorno.
El truco del archivo .pth
Para entender el alcance del ataque hay que detenerse en el mecanismo. Python, al iniciarse, examina el directorio donde se instalan los paquetes de terceros en busca de archivos con extensión .pth. Su función original es inocente: añadir rutas al camino de búsqueda de módulos. Sin embargo, la especificación permite que una línea de uno de esos archivos que comience con la palabra import se ejecute como código. Es una característica antigua, documentada y usada legítimamente por herramientas de empaquetado y entornos de desarrollo.
Los atacantes aprovecharon esa característica. Cada una de las dos versiones maliciosas incluía en su paquete un archivo de ese tipo, que se copiaba en el directorio de paquetes durante la instalación. A partir de ese momento, cada arranque del intérprete en ese entorno ejecutaba el contenido, sin que importara si el usuario trabajaba con agent-framework, con otra biblioteca o con ninguna. Incluso el propio gestor pip, que es un programa de Python, activaba el código al ejecutarse.
Los archivos usaron nombres que pretendían pasar por herramientas de diagnóstico o de metadatos: agent_framework_meta.pth en la 1.26.1 y af_runtime_diag.pth en la 1.26.2. La elección de nombres plausibles es una técnica de camuflaje habitual, pensada para que una revisión rápida del directorio de paquetes no despierte sospechas. En la segunda versión, además, se cambió la forma de organizar el módulo auxiliar, lo que sugiere un intento de variar la huella entre ambas publicaciones.
Este vector tiene una consecuencia práctica importante para la detección. Los análisis habituales que buscan código malicioso en funciones de inicialización o en el contenido de los módulos importados pueden pasar por alto un archivo de configuración de rutas que contiene una línea ejecutable. Muchos escáneres han ido incorporando reglas específicas para estos ficheros, pero la práctica muestra que no todas las herramientas lo hacen, y que los equipos rara vez inspeccionan a mano el directorio de paquetes.
Qué robaba el código malicioso
Según los análisis de las empresas de seguridad que estudiaron las muestras, el objetivo eran las credenciales accesibles desde el entorno donde se ejecutaba el intérprete. Las descripciones señalan credenciales de Azure y secretos de entornos de integración continua, incluidos los asociados a GitHub Actions. La segunda versión añadió la petición de tokens de identidad de la plataforma de automatización, un tipo de credencial de vida corta que permite autenticarse ante servicios en la nube sin guardar contraseñas.
Este detalle muestra una comprensión clara de cómo se despliega hoy el software moderno. Muchas organizaciones han sustituido las claves de larga duración por identidades federadas, precisamente para reducir el riesgo de filtración. Pero esos mecanismos solo son seguros si el código que se ejecuta dentro de la tubería es de confianza. Si una dependencia comprometida corre en el mismo trabajo que solicita el token, puede obtenerlo igual que lo haría el código legítimo.
Los datos recogidos se enviaban a un servicio externo bajo control de los atacantes. No es necesario entrar en el detalle del destino para extraer la conclusión operativa: lo que salió de un entorno comprometido debe darse por perdido. No existe una forma de saber con certeza qué se leyó y qué no, así que la respuesta prudente consiste en considerar expuestos todos los secretos accesibles desde la máquina o la tubería en el momento en que el intérprete arrancó con la versión maliciosa instalada.
En términos de impacto potencial, el abanico es amplio. Una credencial de nube puede dar acceso a cuentas cloud, almacenes de datos y máquinas virtuales. Un token de plataforma de código puede permitir leer repositorios privados, modificar flujos de trabajo o publicar nuevas versiones de otros paquetes. Esta última posibilidad es la que inquieta más a los especialistas, porque convierte un compromiso en el origen de compromisos posteriores.
Atribución: lo que aún no se sabe
Hasta el momento de redactar este artículo no hay una atribución confirmada a ningún grupo o persona. Las firmas que analizaron el caso describen el comportamiento técnico, las similitudes y las diferencias entre las dos versiones, pero no han establecido de forma concluyente quién está detrás. Por rigor, cualquier nombre que circule en foros o redes sociales debe tratarse como especulación mientras no lo respalden pruebas verificables.
La falta de atribución no es excepcional. En los incidentes de cadena de suministro de software, identificar al responsable puede requerir semanas o meses de análisis de infraestructura, patrones de código y movimientos posteriores, y a menudo termina sin una respuesta definitiva. Mientras tanto, los equipos afectados no pueden esperar a saber quién fue: la remediación depende del comportamiento del código, no de la identidad del autor.
Tampoco está confirmado cómo los atacantes obtuvieron la capacidad de publicar en el proyecto. Las hipótesis posibles incluyen el robo de una credencial de publicación, el compromiso de una cuenta de un mantenedor o el abuso de algún proceso automatizado, pero ninguna ha sido establecida de forma oficial en las fuentes consultadas. Quien lea explicaciones categóricas sobre este punto debería preguntarse en qué evidencia se apoyan.
Sí es defendible afirmar que la publicación no parece haber seguido el flujo habitual de lanzamiento del proyecto, dada la falta de una etiqueta correspondiente en el repositorio. Pero ese dato describe un síntoma, no una causa. La investigación completa corresponde al propio proyecto y al operador del índice, y es previsible que se publiquen más detalles cuando concluya.
Antecedentes: una técnica que se repite
El incidente no es un hecho aislado. Los ataques a la cadena de suministro a través de repositorios públicos llevan años creciendo, tanto en Python como en JavaScript y otros ecosistemas. Entre las variantes más conocidas están el typosquatting, que consiste en publicar paquetes con nombres casi idénticos a los populares; la confusión de dependencias, que explota nombres internos de empresas; y el secuestro de cuentas de mantenedores para publicar versiones envenenadas de paquetes legítimos.
Lo que distingue este caso es la combinación de un paquete real, de un proveedor de primer nivel y con tráfico significativo, con una técnica de ejecución en el arranque del intérprete. El uso de archivos .pth como vector no es nuevo en el mundo de la seguridad, pero se ha ido popularizando entre los atacantes porque elude el modelo mental habitual según el cual solo importa el código que se importa.
También es coherente con una tendencia más amplia: los atacantes apuntan a las herramientas de los desarrolladores y a las tuberías de automatización porque allí se concentran los secretos. Un equipo puede proteger con esmero su aplicación en producción y, aun así, dejar sus credenciales más sensibles en un entorno de compilación que instala dependencias sin ninguna verificación.
Otro paralelismo es la rapidez. Los incidentes recientes de este tipo comparten una ventana de exposición corta, de minutos u horas, seguida de una retirada veloz. Eso indica que los mecanismos de detección de los índices y de las empresas de seguridad han mejorado, pero también que a los atacantes les basta una ventana pequeña si el objetivo se actualiza de forma automática. La defensa, por tanto, no puede basarse solo en que alguien retire el paquete a tiempo.
Cómo saber si un entorno quedó afectado
La primera tarea tras un incidente así es inventariar. Hay que determinar qué máquinas, contenedores, entornos virtuales y tuberías instalaron agent-framework durante el 17 de noviembre y cuál fue la versión resultante. Los registros de las tuberías de integración continua suelen conservar la salida de la instalación de dependencias, y los ficheros de bloqueo de versiones indican qué se resolvió en cada compilación. Si el proyecto fijaba la versión en 1.26.0 o anterior, el riesgo de este incidente concreto desaparece, aunque conviene verificarlo.
Después, conviene revisar el contenido real de cada entorno. En el directorio de paquetes de terceros de cada entorno virtual hay que buscar la presencia de los archivos .pth con los nombres señalados por los analistas, así como de cualquier otro fichero de ese tipo que no se reconozca. Muchos entornos legítimos tienen algunos archivos .pth, por lo que lo importante es comparar con una línea base conocida y desconfiar de los que contengan líneas ejecutables sin una razón clara.
Los contenedores merecen una atención particular. Una imagen construida durante la ventana de exposición puede haber incorporado la versión maliciosa y seguir circulando por registros internos, aunque el paquete ya no esté disponible en el índice. Reconstruir imágenes desde cero, con dependencias fijadas, es más seguro que intentar limpiarlas a mano. Lo mismo vale para cachés de pip y para espejos internos de paquetes, que podrían conservar las versiones retiradas.
Si se encuentra evidencia de instalación, el entorno debe tratarse como comprometido. Eso implica aislarlo, preservar los registros para el análisis posterior y no limitarse a desinstalar el paquete. Desinstalar la biblioteca no deshace lo que el código ya haya enviado, y un archivo residual podría seguir ejecutándose si la desinstalación no lo elimina. Lo prudente es recrear el entorno completo desde una fuente de confianza.
Por último, conviene revisar los registros de actividad de los servicios en la nube y de las plataformas de código en busca de accesos anómalos desde el 17 de noviembre en adelante: autenticaciones desde ubicaciones inesperadas, creación de nuevos tokens, cambios en permisos o en flujos de trabajo y descargas masivas de repositorios. Una intrusión posterior puede producirse horas o días después del robo.
Rotar secretos: el paso que no se puede omitir
Si hay indicios de exposición, la rotación de credenciales es la medida central. La regla práctica es rotar todo lo que fuera accesible desde el entorno afectado, no solo lo que se cree que se usó. Esto incluye claves y secretos de aplicaciones en Azure, contraseñas de cuentas de servicio, tokens de acceso personal a plataformas de código, secretos almacenados en la configuración de las tuberías, claves de acceso a registros de contenedores y cualquier clave de interfaz de modelos de lenguaje o de otros servicios que estuviera en variables de entorno.
El orden importa. Primero se revocan o rotan las credenciales de mayor privilegio y las que dan acceso a otras credenciales, como los almacenes de secretos. Después se actúa sobre los accesos de lectura. Es fundamental revocar las credenciales antiguas y no limitarse a crear nuevas, porque un secreto robado sigue siendo válido hasta que se invalida expresamente. En el caso de sesiones activas, hay que cerrarlas o forzar la reautenticación.
Los tokens de identidad federada y de vida corta ayudan, pero no eliminan la necesidad de revisar. Si una tubería obtuvo tokens mientras corría la versión maliciosa, esos tokens podrían haberse usado dentro de su periodo de validez. Conviene revisar qué permisos tenía la identidad de la tubería y restringirlos al mínimo necesario, de modo que un robo futuro tenga un alcance limitado.
La rotación debe documentarse. Registrar qué se rotó, cuándo y quién lo hizo evita que se pasen por alto secretos y facilita la auditoría posterior. En equipos grandes, un inventario actualizado de secretos y de sus propietarios es lo que marca la diferencia entre una respuesta de horas y una de semanas. Quien no dispone de ese inventario descubre en estos momentos lo costoso que resulta construirlo bajo presión.
Finalmente, hay que vigilar la actividad en las semanas siguientes. Los atacantes pueden retener datos robados y utilizarlos más tarde, cuando la atención ha disminuido. Mantener alertas reforzadas sobre inicios de sesión, creación de recursos y cambios en repositorios durante un periodo prolongado es una medida razonable.
Fijar versiones y exigir hashes
La prevención empieza por el control de lo que se instala. Fijar versiones exactas de las dependencias, en lugar de aceptar rangos abiertos o la última disponible, evita que una tubería incorpore automáticamente una publicación nueva sin que nadie la haya revisado. Un proyecto que declaraba la versión 1.26.0 no habría descargado las dos versiones maliciosas por sí solo. El coste es tener que actualizar de forma deliberada, y ese coste es el precio de la revisión.
Fijar la versión es un primer escalón. El segundo es exigir comprobación de hashes. Los gestores de paquetes permiten registrar la huella criptográfica esperada de cada archivo descargado y rechazar cualquier artefacto que no coincida. Con este modo activado, un archivo distinto al previamente aprobado, aunque lleve el mismo número de versión, no se instala. Para que funcione bien, el archivo de requisitos debe incluir los hashes de todas las dependencias, también las transitivas, y generarse con una herramienta de bloqueo reproducible.
Hay que ser realista sobre los límites. Un hash protege contra la sustitución de un artefacto ya aprobado, pero no protege contra una versión nueva que alguien apruebe sin revisarla. Si un desarrollador actualiza a la versión maliciosa y genera nuevos hashes automáticamente, la protección no sirve. Por eso las actualizaciones deben pasar por un proceso de revisión humana o, al menos, por controles automáticos adicionales.
Una práctica complementaria es introducir una demora deliberada antes de adoptar publicaciones recientes. Si una organización solo acepta versiones con cierta antigüedad, por ejemplo de unos días, la mayoría de incidentes que se detectan y retiran en cuestión de horas nunca llegan a sus sistemas. Algunas herramientas y gestores ya incorporan opciones para configurar esa antigüedad mínima, y los bots de actualización de dependencias suelen permitir ajustes similares.
También conviene usar un espejo o proxy interno de paquetes que actúe como filtro. Un repositorio intermedio permite aprobar versiones, almacenar copias y bloquear rápidamente un paquete problemático para toda la organización con un solo cambio. A cambio, exige mantenimiento y una política clara sobre quién decide qué versiones se admiten.
Endurecer entornos, tuberías y permisos
Más allá de las dependencias, hay que reducir el daño que puede causar una dependencia comprometida. El principio es el mínimo privilegio: que un trabajo de compilación o de pruebas solo disponga de los secretos que necesita, y solo durante el tiempo que los necesita. Separar las fases de instalación y prueba de las de despliegue evita que el código instalado desde el exterior coincida en el mismo proceso con las credenciales más delicadas.
En las plataformas de automatización, conviene limitar los permisos por defecto de los tokens que se entregan a cada trabajo, usar identidades federadas con condiciones estrictas, como restringir qué repositorio, rama o entorno puede solicitarlas, y evitar exponer secretos a trabajos que ejecutan código de contribuciones externas. Revisar periódicamente los permisos concedidos suele revelar accesos que nadie recordaba haber otorgado.
El aislamiento de los entornos de desarrollo también cuenta. Trabajar con agentes de IA y bibliotecas experimentales en máquinas o contenedores desechables, sin sesiones permanentes abiertas en la nube ni claves personales en el sistema, limita lo que un archivo ejecutado al arrancar puede encontrar. Si el entorno no tiene secretos, el robo no rinde nada.
Otra medida útil es la monitorización de cambios en los directorios de paquetes. Algunas herramientas de seguridad pueden alertar cuando aparece un archivo .pth nuevo con contenido ejecutable, o cuando un proceso de instalación realiza conexiones de red inesperadas. Restringir la salida a Internet de las tuberías a una lista de destinos permitidos es una barrera eficaz: aunque el código malicioso se ejecute, no logra enviar los datos a su destino.
Por último, conviene mantener un procedimiento de respuesta ensayado. Saber de antemano quién decide, cómo se aísla un entorno, cómo se rotan los secretos y cómo se comunica a los equipos acelera la reacción. Los incidentes de cadena de suministro tienen la particularidad de que la información llega por canales externos, a menudo de madrugada, y la capacidad de actuar con rapidez depende de la preparación previa.
Lecciones para mantenedores y para la industria
Para quienes mantienen paquetes populares, el incidente es un recordatorio de la importancia de proteger el acceso de publicación. Activar la autenticación multifactor, utilizar el mecanismo de publicación de confianza que permite vincular el índice con un flujo de lanzamiento concreto en lugar de guardar tokens de larga duración, y limitar el número de personas con permisos son medidas básicas. Cuando un proyecto tiene tanta audiencia, la publicación debería exigir además una aprobación adicional o un proceso reproducible que deje rastro.
También es recomendable que los proyectos comparen lo publicado en el índice con lo que existe en su repositorio de código. Una alerta automática cuando aparece una versión sin etiqueta asociada habría permitido detectar la anomalía en minutos. Y publicar un procedimiento claro de comunicación ante incidentes, con avisos rápidos y detalles técnicos útiles, ayuda a que los usuarios actúen a tiempo.
Para los operadores de índices, el caso refuerza la discusión sobre cómo tratar los archivos de ejecución automática en el arranque y sobre la rapidez de la cuarentena. La retirada en menos de una hora es una buena noticia comparada con casos de otros años, pero el hecho de que la segunda versión se publicara tras la primera cuarentena evidencia que revocar el acceso del publicador debe ser inmediato y completo.
Para las organizaciones usuarias, la lección es que la confianza en el nombre de un proveedor no sustituye a los controles técnicos. Que un paquete lo publique una gran empresa no lo hace inmune, porque lo que se compromete no es la empresa sino su canal de distribución. Tratar las dependencias externas como código no auditado, con verificaciones proporcionales al riesgo, es la postura realista.
Finalmente, hay una reflexión sobre el ecosistema de agentes de IA. Estos marcos de trabajo son jóvenes, evolucionan deprisa y se adoptan con entusiasmo, a veces con menos disciplina de seguridad que otras partes del software. Su proximidad a credenciales y a datos sensibles los hace objetivos atractivos. Quien construye sistemas con agentes debería aplicarles los mismos controles de cadena de suministro que a cualquier componente crítico.
Situación actual de la historia
A fecha de 20 de noviembre de 2026, las dos versiones maliciosas, 1.26.1 y 1.26.2, han sido retiradas y no pueden descargarse del índice. La versión 1.26.0 figura como la última limpia conocida. Existe un aviso de seguridad público que identifica el paquete afectado y las versiones comprometidas, y varias firmas de seguridad han publicado análisis técnicos con indicadores que permiten comprobar si un entorno fue tocado.
No hay una atribución confirmada del ataque, y no se ha establecido oficialmente cómo se obtuvo la capacidad de publicar. Tampoco se ha publicado una cifra fiable del número de sistemas que descargaron las versiones maliciosas, de modo que cualquier estimación del alcance real debe tomarse con cautela. Lo único que puede afirmarse es que el volumen habitual de descargas del paquete, de unas 190.000 a 200.000 al mes, da una idea del universo potencial, no del número de afectados.
La recomendación de las empresas que investigaron el caso es coherente: quien instalara cualquiera de las dos versiones debe considerar el entorno como expuesto, eliminar el paquete y los archivos asociados, recrear el entorno y rotar las credenciales accesibles. Es previsible que el proyecto y el operador del índice publiquen más información conforme avance su investigación, y conviene seguir sus comunicaciones oficiales.
Una lista de comprobación para esta semana
Para convertir lo anterior en acciones concretas, un equipo puede seguir un orden sencillo durante los próximos días. Primero, identificar todos los proyectos que dependen de agent-framework, directa o indirectamente, y anotar la versión instalada en cada entorno y la fecha de la última instalación. Segundo, revisar los registros de compilación del 17 de noviembre para detectar instalaciones en la ventana de exposición.
Tercero, inspeccionar los entornos activos en busca de los dos archivos .pth conocidos y de cualquier otro fichero de ese tipo inesperado. Cuarto, recrear desde cero los entornos y las imágenes que hayan tenido contacto con las versiones afectadas. Quinto, rotar de forma ordenada todos los secretos accesibles desde esos entornos, empezando por los de mayor privilegio, y revocar los antiguos.
Sexto, revisar los registros de actividad de la nube y de las plataformas de código en busca de comportamientos anómalos desde la fecha del incidente. Séptimo, fijar versiones con hashes en todos los proyectos que aún no lo hagan y valorar una antigüedad mínima para las publicaciones nuevas. Octavo, reducir los permisos de las tuberías y limitar su salida de red.
Noveno, dejar constancia por escrito de lo realizado y de lo aprendido, para que la siguiente alerta encuentre al equipo mejor preparado. Muchos de estos pasos son tareas que se aplazan por falta de urgencia, y un incidente ajeno es una buena ocasión para ejecutarlas sin esperar a ser la víctima.
Conclusiones
El compromiso de agent-framework en PyPI demuestra que un nombre de confianza y una distribución masiva no bastan para garantizar la seguridad de una dependencia. Dos versiones, 1.26.1 y 1.26.2, estuvieron disponibles durante menos de una hora el 17 de noviembre de 2026, y su diseño permitía robar credenciales de Azure y de entornos de integración continua con solo arrancar Python, gracias a un archivo .pth que se ejecuta sin que nadie importe el paquete.
Lo comprobado hasta ahora es suficiente para actuar: la última versión limpia es la 1.26.0, los entornos que instalaron las versiones afectadas deben considerarse expuestos y la respuesta adecuada combina eliminación, recreación de los entornos y rotación completa de secretos. Lo que no se sabe todavía, la atribución y el método de acceso del atacante, no debería frenar esas acciones.
A medio plazo, la mejor defensa es estructural. Fijar versiones, exigir hashes, esperar un tiempo prudente antes de adoptar publicaciones nuevas, filtrar mediante un espejo interno, limitar permisos y restringir la salida de red reducen tanto la probabilidad de recibir un paquete envenenado como el daño que puede causar si llega. Ninguna de estas medidas es espectacular, pero juntas convierten un incidente potencialmente grave en una molestia manejable, y eso es lo que separa a los equipos preparados de los que se enteran tarde.
