El código malicioso es cualquier código escrito para hacer que un sistema haga lo que su dueño nunca autorizó: destruir o robar datos, entregarle el control a un atacante, o alterar en silencio lo que hace un programa legítimo. El NIST lo describe como un programa “covertly inserted into another program”, insertado de forma encubierta dentro de otro programa, y esa palabra — encubierta — es la parte que la mayoría de las definiciones se salta. El código malicioso rara vez se anuncia. Llega dentro de algo que se ve bien.
De las 100 entradas más recientes de la Fluid Attacks Database el 11 de noviembre de 2026, 25 eran paquetes maliciosos, publicados bajo identificadores como MAL-2026-19118 y no como CVE. Tres de ellos llevaban el nombre de la misma librería de npm bajo scopes distintos; otros tres eran variantes casi idénticas de un mismo nombre de paquete. Ninguno era una falla que alguien cometió por accidente. Todos eran código escrito a propósito y publicado donde los desarrolladores lo iban a instalar.
Esta página cubre qué es el código malicioso y en qué se diferencia de una vulnerabilidad, los tipos que vas a encontrar, cómo llega a un sistema — por dependencias, actualizaciones y pipelines de compilación —, cómo lo detectamos en Fluid Attacks y cómo se ve la prevención cuando el vehículo de entrega es software que tu equipo decidió confiar.
¿Qué es el código malicioso?
El código malicioso es software, o un fragmento de software, construido con la intención de dañar el sistema que lo ejecuta. La intención es lo que lo define. Un desbordamiento de búfer que le permite a un atacante ejecutar comandos es un defecto introducido por error; un backdoor que le abre la puerta a ese mismo atacante es código que alguien escribió para que estuviera ahí.
Esa distinción importa más que el vocabulario que la rodea. «Código malicioso» y «malware» se usan indistintamente, y el NIST los trata como lo mismo. La división útil no está entre las dos palabras, sino entre el código que fue insertado y el código que fue mal manejado.
Eso tiene una consecuencia práctica: si solo buscas código malicioso en el endpoint, estás mirando el último paso de un camino que empezó en otra parte.
El código malicioso no es lo mismo que una vulnerabilidad
Una vulnerabilidad es una debilidad en código escrito de buena fe. El código malicioso es lo contrario: el código está haciendo exactamente lo que su autor quería.
Los dos interactúan todo el tiempo — un atacante explota una vulnerabilidad para ejecutar código malicioso —, y por eso se confunden. Pero necesitan respuestas distintas. Una vulnerabilidad se parcha. El código malicioso no se parcha; se elimina, y después se averigua qué hizo mientras estuvo ahí.
El requisito de seguridad 155, “Application free of malicious code” de Fluid Attacks lo plantea como lo vive un equipo de desarrollo. El código malicioso “can be imported as part of third party libraries, which may be intentionally malicious”, es decir, puede importarse como parte de librerías de terceros intencionalmente maliciosas, o “come as a backdoor left by one of the developers”, llegar como una puerta trasera que dejó uno de los desarrolladores. El requisito mapea a CWE-507 (Trojan horse), CWE-510 (Trapdoor) y CWE-511 (Logic/Time bomb), al control 8.26 de ISO 27001 y a SI-3 de FedRAMP.
Tipos de código malicioso
Lo que importa en la práctica no es qué hace el código una vez se ejecuta, sino cómo se propaga y cómo llegó ahí. Esas dos propiedades deciden tu respuesta.
Tipo | Qué hace | ¿Se autorreplica? | Entrada típica |
|---|---|---|---|
Virus | Se adhiere a un archivo o programa y se ejecuta cuando ese archivo se ejecuta | Sí, necesita un anfitrión | Archivo o documento infectado |
Worm | Se copia por una red o un ecosistema sin acción del usuario | Sí, por sí solo | Servicio de red, repositorio de paquetes |
Troyano | Se presenta como software legítimo para que lo instalen | No | Descarga, tienda de aplicaciones, actualización comprometida |
Cifra archivos o sistemas y exige un pago, como en Colonial Pipeline | Varía | Phishing, servicio expuesto, dropper | |
Spyware | Vigila la actividad, registra pulsaciones del teclado, captura la pantalla, la cámara o el micrófono | No | Instalador empaquetado, troyano, extensión maliciosa |
Rootkit | Oculta la presencia del atacante subvirtiendo el sistema operativo o el firmware | No | Instalación posterior al compromiso |
Backdoor | Da acceso encubierto que evade la autenticación | No | Insertado en el código fuente, la compilación o una actualización |
Bomba lógica | Permanece inactiva hasta que una condición o una fecha la dispara | No | Insertada por alguien con acceso de commit |
Adware | Muestra publicidad no deseada | No | Instalador empaquetado |
Dos correcciones que vale la pena hacer, porque las dos son comunes y las dos están mal.
Un troyano no es un virus. Un virus se replica adhiriéndose a otros archivos; un troyano no se replica en absoluto. Se instala porque alguien eligió instalarlo, creyendo que era otra cosa. Ese es todo su mecanismo, y por eso los troyanos sobreviven donde los virus no.
No todo el adware es código malicioso. El software financiado con publicidad que dice lo que hace y se puede desinstalar es un modelo de negocio, no un ataque. Se convierte en código malicioso cuando se oculta, resiste la desinstalación o carga una segunda carga útil. La línea es la transparencia, no la molestia.
Los backdoors y las bombas lógicas merecen más atención de la que listas como esta les dan: son los tipos de código malicioso que te llegan dentro de software que pagaste o de código que tu propio equipo integró. No se propagan. No lo necesitan.
El código malicioso en Fluid Attacks
Tratamos el código malicioso primero como un problema de cadena de suministro de software y después como un problema de endpoint, porque ahí es donde está la exposición de nuestros clientes. Esto es lo que buscamos, lo que podemos probar y dónde se detienen nuestras cifras.
Qué buscamos en el código de terceros
Nuestro catálogo de debilidades le da al código malicioso en dependencias una clase propia: 448, “Use of software with malware”, una dependencia del proyecto que “contains code or components suspected of being compromised by malware or malicious behavior”, esto es, que contiene código o componentes sospechosos de estar comprometidos por malware o comportamiento malicioso. Su impacto listado es acceso no autorizado y control total de la infraestructura de la aplicación, pérdida de disponibilidad y propagación a otras aplicaciones, servidores o redes: la dependencia se vuelve el vector, no el objetivo.

Fluid Attacks reporta las dependencias comprometidas por código malicioso como la debilidad 448.
Dos cosas de esa ficha vale la pena leerlas con cuidado. Su madurez de explotación es A, de Attacked: esto no es teórico. Y su tiempo esperado de remediación es de 60 minutos: el arreglo suele ser rápido una vez que sabes; lo difícil es saber.
Entre los requisitos con los que conecta están el 155, arriba, y el 262, “Verify third-party components”, que también gobierna la confusión de dependencias.
Cómo se ve en la práctica
Qué instrumentamos | Qué busca | Dónde queda la evidencia |
|---|---|---|
Dependencias que cargan código malicioso o vulnerabilidades conocidas, directas y transitivas | Sección Packages, con el archivo y la línea que la importa | |
Advisories de malware | Paquetes publicados con comportamiento malicioso y sin CVE | Identificadores MAL propios en la base de datos pública |
Análisis de alcanzabilidad | Si tu código realmente llama a una función vulnerable | Etiqueta “Reachable” en el paquete afectado |
Código malicioso en tu propio repositorio: backdoors, bombas lógicas, lógica insertada | Vulnerabilidad reportada con el código en contexto | |
Exportación de SBOM | El inventario completo de componentes, con transitividad y etapa de compilación o ejecución | Descarga en CycloneDX o SPDX |

La sección Packages lista cada dependencia de terceros en los repositorios de un grupo, con las vulnerabilidades y ubicaciones de cada una.
En la plataforma, la sección Packages muestra de cada dependencia su “location in your projects and if it contains malware”: su ubicación en tus proyectos y si contiene malware. También registra si un componente se usa en etapa de compilación o de ejecución, lo que cambia hasta dónde puede llegar un paquete malicioso.
Qué detecta lo automatizado y qué no
En el benchmark de Fluid Attacks de herramientas de AppSec de terceros contra una aplicación web sembrada con 1.201 vulnerabilidades en 105 categorías CWE, un pentester reportó 1.076 de ellas: 89,6 % de recall con 100 % de precisión. El mejor escáner automatizado del mismo ejercicio, el nuestro, llegó a 22,7 % de recall, encontrando 273 de las 1.201, y cubrió el 8,8 % de la exposición total al riesgo.
Dónde se detienen esas cifras
Ese benchmark mide vulnerabilidades, no código malicioso. Sería fácil trasladar el 89,6 % a una afirmación sobre detección de código malicioso, y estaría mal: encontrar una falla de inyección en una aplicación sembrada y detectar un script de postinstall que exfiltra variables de entorno son problemas distintos con techos distintos. Lo publicamos porque es reproducible, no porque se traslade.Dos límites más que preferimos decir a que los descubras:
La alcanzabilidad y la detección de malware responden preguntas distintas. Nuestra documentación las lista por separado por algo. La alcanzabilidad te dice si tu código llama a la función vulnerable de una dependencia. No dice nada sobre si esa dependencia contiene código malicioso, porque un paquete hostil no espera a que lo llamen: un script de instalación se ejecuta al instalar.
Un lock file protege la siguiente compilación, no la que ya hiciste. Fija la versión que instalaste para que una publicación maliciosa dentro del rango declarado no se cuele después. Si la versión que fijaste ya venía comprometida, el lock file la mantiene en su lugar con toda fidelidad.
El control que decide casi todo lo demás
Si implementas una sola cosa de esta página, implementa lock files con hashes. Nuestra documentación sobre ellos expone el caso de falla sin rodeos: “Attackers have taken control of maintainer accounts and released malicious versions of popular packages”, los atacantes han tomado control de cuentas de mantenedores y publicado versiones maliciosas de paquetes populares. Sin un lock file, “the next build can install a malicious version that is in the declared range”: la siguiente compilación puede instalar una versión maliciosa que esté dentro del rango declarado.
Con los hashes registrados, el gestor de paquetes “stops the installation when a package is different from the package that you locked”, detiene la instalación cuando un paquete es distinto del que fijaste: verificación de integridad en cada compilación. Nuestra documentación lista el archivo y el comando de CI/CD de 15 gestores de paquetes, desde npm ci hasta cargo build --locked, además de qué hacer con pip, Maven y sbt, que no producen ninguno.
Para profundizar: nuestra visión general de la seguridad de la cadena de suministro de software cubre el conjunto más amplio de prácticas, y la página sobre análisis de composición de software explica cómo se construyen y se evalúan los inventarios de componentes.
Cómo entra el código malicioso a un sistema
El código malicioso necesita un mecanismo de entrega, y la lista creció mucho más allá de los adjuntos de correo. Estas son las vías que importan hoy.
Phishing e ingeniería social. Sigue siendo la apertura más común, pero la ingeniería social ahora apunta a quienes publican código, no solo a los usuarios finales. El compromiso de npm de septiembre de 2025 empezó con un correo de phishing a un mantenedor.
Descargas y medios extraíbles. Software pirateado, instaladores falsos, extensiones de navegador maliciosas, memorias USB. La vía clásica, y todavía funciona.
Explotación de una vulnerabilidad. El atacante no inserta código malicioso en tu software; usa una falla para ejecutar el suyo.
Actualizaciones comprometidas. Una actualización firmada con certificados legítimos, entregada por el canal del propio proveedor, que carga código que el proveedor no escribió.
Dependencias maliciosas. Un paquete de typosquatting publicado con un nombre parecido a uno real, un paquete abandonado que alguien más volvió a registrar, o un paquete legítimo cuya cuenta de mantenedor fue tomada. La confusión de dependencias también va aquí: cuando un proyecto declara sus dependencias de forma ambigua, un atacante puede lograr que el gestor de paquetes resuelva hacia el suyo en vez del tuyo.
CI/CD y herramientas de desarrollo. Ejecutores de compilación, acciones reutilizables, extensiones de IDE y, ahora, los archivos de instrucciones que leen los agentes de programación con IA. La técnica T1195.001 de MITRE ATT&CK, Compromise Software Dependencies and Development Tools, cubre todo eso, y anota que los archivos de habilidades de agentes pueden pasar el filtrado de los repositorios y el escaneo por firmas, porque son lenguaje natural y no código ejecutable.
Vale la pena señalar una técnica de evasión porque derrota a la revisión de código misma: en octubre de 2025, los atacantes escondieron código malicioso en extensiones de VS Code usando caracteres Unicode invisibles que se ven como espacio en blanco en una vista diff pero se ejecutan normalmente.
El código malicioso en la cadena de suministro de software
El código malicioso de mayor impacto de los últimos cinco años no llegó como una descarga sospechosa. Llegó como una actualización legítima o un paquete confiable. Eso es un ataque a la cadena de suministro de software: el atacante compromete algo que está aguas arriba de ti, y tu propia confianza hace la entrega. Cuatro casos, todos documentados por nuestro equipo, muestran el patrón.
Caso | Año | Cómo entró el código | Qué hizo |
|---|---|---|---|
2020 | Backdoor insertado en la compilación, enviado como actualización firmada | Canal encubierto hacia servidores controlados por el atacante, en miles de organizaciones | |
2025 | Etiquetas de versión repuntadas a un commit malicioso en una GitHub Action | Volcó secretos de CI/CD desde la memoria del ejecutor a los logs del workflow | |
2025 | Phishing a un mantenedor y publicación de versiones maliciosas | Interceptor en el navegador que reescribía transacciones de criptomonedas | |
2025 | Carga maliciosa en un script de postinstall secuestrado | Robó credenciales y se republicó solo en más paquetes |
SolarWinds rompió el supuesto que sostiene a casi todas las defensas de endpoint: el componente comprometido estaba firmado digitalmente y entregado por el canal oficial de actualizaciones del proveedor. La verificación de firma confirmó que el paquete era auténtico. Lo era. El código malicioso estaba adentro.
El caso de la GitHub Action aplica la misma lógica a la compilación. Más de 23.000 repositorios dependían de ella; nuestro advisory de CVE-2025-30066 lo clasifica bajo la debilidad 448 con CWE-506, Embedded Malicious Code, y registra un puntaje EPSS de 0,88385, el percentil 99,47 de probabilidad de explotación.
Shai-Hulud volvió a cambiar la economía del ataque. Al robar credenciales y usarlas para publicarse en otros paquetes, sacó al atacante del circuito. Un ataque a la cadena de suministro de software que se propaga solo convierte al ecosistema en la red de distribución.
Cómo detectar y prevenir el código malicioso
La detección de código malicioso se divide según dónde está el código. El código de tu propio repositorio necesita revisión. El código que importaste necesita inteligencia sobre su origen.
Escanea las dependencias contra inteligencia de malware, no solo contra fuentes de CVE
Esta es la brecha que deja mal parados a los equipos. Un paquete publicado con fines maliciosos nunca recibe un CVE, porque no se divulgó nada: alguien publicó código hostil. Nuestra base de datos los emite bajo identificadores MAL propios, y una herramienta que solo coteja tu manifiesto contra la NVD reporta esos proyectos como limpios.Inventaría lo que despachas
La sección Packages rastrea dependencias directas y transitivas por repositorio y exporta un SBOM en CycloneDX o SPDX. No puedes evaluar un componente que no sabes que tienes, y la mayor parte del inventario es transitiva.Fija versiones y verifica la integridad
Lock files con hashes, más el comando de CI/CD que falla la compilación cuando el lock file está desactualizado.Revisa tu propio código en busca de lógica insertada
Los backdoors, las bombas de tiempo y los cargadores de rootkit no se encuentran cotejando nombres de paquetes. Se encuentran cuando alguien lee el código, que es para lo que están Secure Code Review y el Pentesting as a Service (PTaaS) asistido por código.Pon una compuerta en el pipeline de CI/CD
En el State of Attacks 2026 de Fluid Attacks, que cubre 1.119.396 vulnerabilidades reportadas durante 2025, las organizaciones que usaron nuestro CI Gate remediaron el 72,2 % de sus vulnerabilidades reportadas, frente al 58 % de las que no lo usaron. El mismo reporte encontró que el 70 % de los sistemas evaluados tenía al menos una vulnerabilidad de severidad alta o crítica, frente al 53,3 % del año anterior. Un pipeline de CI/CD que falla la compilación ante una violación de política es el lugar para detener una dependencia sin revisar.Trata la detección como el comienzo de la respuesta
La debilidad 448 recomienda revisar el origen y la integridad de las dependencias afectadas, reemplazarlas y después probar para verificar que el ambiente de producción no esté ya comprometido. Eliminar el código malicioso no deshace lo que hizo con las credenciales que leyó.
Conclusiones
El código malicioso se gana el nombre por la intención, no por la técnica, y las técnicas que importan se movieron. La estampa de la era del endpoint — un adjunto infectado, una memoria USB, una firma de antivirus — todavía describe ataques reales, pero no los que alcanzaron a miles de organizaciones a la vez. Esos llegaron por una actualización firmada, una acción reutilizable de CI/CD y un paquete con dos mil millones de descargas semanales.
Defenderse de eso significa saber de qué está hecho tu software, verificar que esos componentes sean lo que dicen ser, y leer el código que escribe tu propio equipo. Ningún conjunto de controles vuelve inmune a un sistema. La meta alcanzable es que el código malicioso en tu cadena de suministro sea algo que detectas en horas, no algo de lo que te enteras por alguien más.
Preguntas frecuentes
¿El código malicioso es lo mismo que el malware?
Sí, los términos se usan indistintamente. La SP 800-83 del NIST define el malware como “also known as malicious code”: cualquier programa insertado de forma encubierta dentro de otro con la intención de destruir datos, ejecutar programas destructivos o intrusivos, o comprometer la confidencialidad, integridad o disponibilidad de los datos, las aplicaciones o el sistema operativo de la víctima. La distinción más útil es entre el código malicioso, escrito a propósito, y una vulnerabilidad, un defecto introducido por error.
¿Puede un software firmado digitalmente contener código malicioso?
Sí, y los ataques a la cadena de suministro más dañinos funcionaron exactamente así. En el compromiso de SolarWinds Orion de 2020, los atacantes insertaron un backdoor durante la compilación, de modo que la actualización resultante quedó firmada con los certificados legítimos del proveedor y se distribuyó por su canal oficial. La verificación de firma probó que el paquete era auténtico. Lo era. El código malicioso estaba adentro.
¿Cómo entra el código malicioso a los paquetes de código abierto?
Casi siempre por el mantenedor, no por el código. Los atacantes hacen phishing o toman la cuenta de un mantenedor y publican una versión maliciosa de un paquete en el que la gente ya confía, registran nombres parecidos a los populares para que un error de tipeo instale el suyo, o vuelven a registrar paquetes abandonados. MITRE ATT&CK documenta los tres bajo la técnica T1195.001, junto con el compromiso de componentes de CI/CD como las GitHub Actions.
¿Las herramientas automatizadas detectan código malicioso en las dependencias?
En parte, y la brecha es concreta. Una herramienta que coteja tus dependencias contra fuentes de CVE se pierde por completo los paquetes publicados con fines maliciosos, porque esos nunca reciben un CVE. La detección exige una fuente de publicaciones maliciosas confirmadas. De las 100 entradas más recientes de la Fluid Attacks Database el 11 de noviembre de 2026, 25 eran paquetes maliciosos con identificadores MAL en vez de identificadores CVE.
¿Fluid Attacks detecta código malicioso en las dependencias?
Sí. Nuestros escaneos estáticos inventarían las dependencias de terceros de tu software, y la sección Packages muestra de cada una su ubicación en tus proyectos y si contiene malware: una debilidad que catalogamos como la 448, “Use of software with malware”. El código malicioso insertado en tu propio repositorio es otro problema, que cubre el Secure Code Review manual y no el cotejo de componentes.
Conoce lo que tu software está ejecutando de verdad
Nuestros escáneres y pentesters revisan las dos mitades del problema: las dependencias que importaste y el código que escribió tu equipo. Prueba gratuita · Contáctanos.
Empieza ya con la solución de RBVM de Fluid Attacks















