Tabla de contenidos
Title
Tabla de contenidos
Tabla de contenidos
Title

Código malicioso

Updated

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

Ransomware

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.

Entrada de la Fluid Attacks Database sobre uso de software con malware

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

Software Composition Analysis

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

Secure Code Review

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

Sección Packages con las dependencias de terceros y sus vulnerabilidades

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

SolarWinds Orion

2020

Backdoor insertado en la compilación, enviado como actualización firmada

Canal encubierto hacia servidores controlados por el atacante, en miles de organizaciones

tj-actions/changed-files

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

Toma de cuenta en npm

2025

Phishing a un mantenedor y publicación de versiones maliciosas

Interceptor en el navegador que reescribía transacciones de criptomonedas

Shai-Hulud

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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

Reduce el riesgo sin retrasar tus entregas

Resultados rápidos y exactos desde un único programa de seguridad continuo impulsado por IA, escáneres y pentesters.

Reduce el riesgo sin retrasar tus entregas

Resultados rápidos y exactos desde un único programa de seguridad continuo impulsado por IA, escáneres y pentesters.

Reduce el riesgo sin retrasar tus entregas

Resultados rápidos y exactos desde un único programa de seguridad continuo impulsado por IA, escáneres y pentesters.