Identificación de Indicadores de Malware en Linux

CompTIABeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderá técnicas fundamentales para identificar posibles indicadores de malware en un sistema Linux. A través de una serie de ejercicios prácticos, utilizará utilidades estándar de línea de comandos para investigar signos comunes de una intrusión, adquiriendo habilidades prácticas en monitoreo de sistemas y análisis forense básico.

Comenzará observando la actividad sospechosa de procesos, aprendiendo a detectar picos inusuales de CPU y memoria que pueden indicar un proceso malicioso. A continuación, se centrará en el sistema de archivos para detectar creaciones y modificaciones de archivos inesperadas, un indicador clave de actividad no autorizada. Finalmente, practicará el análisis de registros del sistema para encontrar entradas anómalas que puedan apuntar a una brecha de seguridad.

Observar Actividad Sospechosa de Procesos por Picos de CPU y Memoria

En este paso, aprenderá a utilizar utilidades estándar de Linux para monitorear procesos del sistema en busca de picos inusuales en el uso de CPU y memoria. Un consumo repentino y elevado de recursos es un indicador común de software malicioso (malware), un proceso comprometido o una aplicación que funciona mal. Utilizaremos el comando top para monitoreo en tiempo real y la herramienta stress para simular de forma segura un escenario de alta carga. Todos los comandos se ejecutarán desde su directorio ~/project.

Primero, necesita instalar la utilidad stress, ya que no está incluida en el sistema base. Usaremos el gestor de paquetes apt-get. El primer comando actualiza su lista de paquetes y el segundo instala stress.

sudo apt-get update
sudo apt-get install stress -y

Una vez completada la instalación, establezcamos una línea de base visualizando los procesos actuales en el sistema. El comando top proporciona una vista dinámica en tiempo real del sistema en ejecución.

top

Verá una interfaz de pantalla completa que se actualiza continuamente. Preste atención a las columnas %CPU (uso de CPU) y %MEM (uso de memoria). En condiciones normales, estos valores deberían ser relativamente bajos para la mayoría de los procesos. Presione la tecla q para salir de top y regresar a su prompt de comandos.

top - 16:20:42 up 10 min,  1 user,  load average: 0.00, 0.01, 0.00
Tasks: 100 total,   1 running,  99 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.1 us,  0.1 sy,  0.0 ni, 99.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   1987.2 total,    845.5 free,    450.1 used,    691.6 buff/cache
MiB Swap:      0.0 total,      0.0 free,      0.0 used.   1355.2 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
      1 root      20   0  169404  13120   8484 S   0.0   0.6   0:01.55 systemd
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.00 kthreadd
...

Ahora, simulemos un proceso sospechoso que consume una gran cantidad de CPU. Usaremos stress para iniciar un trabajador que realizará cálculos intensivos de CPU durante 60 segundos. El & al final ejecuta el comando en segundo plano, lo que le permite seguir utilizando la terminal.

stress --cpu 1 --timeout 60 &

Verá un ID de proceso (PID) para el trabajo en segundo plano. Ahora, ejecute top rápidamente de nuevo para observar el efecto.

top

Esta vez, debería ver el proceso stress en la parte superior de la lista o cerca de ella, con su valor de %CPU cercano a 100.0. Esto es exactamente lo que buscaría al intentar detectar un proceso que está acaparando la CPU. Después de 60 segundos, el proceso stress terminará automáticamente. Presione q para salir de top.

A continuación, simulemos un proceso que consume una gran cantidad de memoria. Este comando iniciará un trabajador que asignará 256 Megabytes de memoria y la mantendrá durante 60 segundos.

stress --vm 1 --vm-bytes 256M --timeout 60 &

Nuevamente, ejecute top inmediatamente para ver el impacto.

top

En la salida de top, busque el proceso stress. Esta vez, su %CPU será bajo, pero su valor de %MEM será significativamente mayor que el de otros procesos, lo que demuestra una fuga de memoria o un ataque intensivo en memoria. Esta técnica le ayuda a identificar un consumo de recursos anómalo que justifica una mayor investigación. Presione q para salir.

Detectar Creaciones y Modificaciones Inesperadas de Archivos

En este paso, aprenderá a detectar actividad sospechosa en el sistema de archivos, como la creación o modificación inesperada de archivos. Los atacantes a menudo crean o alteran archivos para establecer persistencia, almacenar cargas maliciosas o manipular configuraciones del sistema. Utilizaremos dos potentes herramientas de línea de comandos: find para buscar archivos basándose en sus tiempos de modificación, y inotifywait para realizar un monitoreo en tiempo real de eventos de directorios. Todas las operaciones se llevarán a cabo en su directorio ~/project.

Primero, usemos el comando find para localizar archivos que han sido modificados recientemente. Esto es útil para auditorías de seguridad periódicas. Creemos un archivo de configuración de ejemplo para monitorear.

echo "SERVER_IP=192.168.1.1" > ~/project/app.conf

El comando find puede buscar archivos basándose en varios criterios. Usaremos la opción -mmin, que significa "modificado hace minutos". El siguiente comando encontrará todos los archivos en el directorio actual (.) que fueron modificados en los últimos 5 minutos.

find . -mmin -5

La salida listará el archivo que acaba de crear.

./app.conf

Ahora, simulemos que un atacante modifica este archivo de configuración.

echo "MALICIOUS_PAYLOAD=..." >> ~/project/app.conf

Si vuelve a ejecutar el comando find, mostrará nuevamente app.conf porque su tiempo de modificación se ha actualizado. Esta es una forma sencilla de detectar cambios recientes. Ahora, simulemos que un atacante deja caer un nuevo archivo, una táctica común.

touch ~/project/hidden_script.sh

Ejecute el comando find una vez más.

find . -mmin -5

Ahora lista tanto el archivo modificado como el recién creado, demostrando cómo puede identificar rápidamente la actividad reciente del sistema de archivos.

./app.conf
./hidden_script.sh

Si bien find es útil para auditorías, no proporciona alertas en tiempo real. Para eso, podemos usar inotify-tools. Primero, debe instalar el paquete.

sudo apt-get update
sudo apt-get install -y inotify-tools

El comando principal es inotifywait, que puede monitorear un archivo o directorio para eventos específicos. Ejecutémoslo en modo de monitoreo (-m) en nuestro directorio ~/project. El & lo ejecutará como un proceso en segundo plano para que pueda seguir usando su terminal.

inotifywait -m ~/project &

El comando ahora está observando silenciosamente los cambios. Realicemos algunas acciones para activarlo. Primero, cree un archivo.

echo "new file" > ~/project/new_file.txt

Inmediatamente verá una salida de inotifywait informando el evento CREATE.

/home/labex/project/ CREATE new_file.txt

Ahora, modifique el archivo.

echo "modified" >> ~/project/new_file.txt

La herramienta informa un evento MODIFY.

/home/labex/project/ MODIFY new_file.txt

Finalmente, elimine el archivo.

rm ~/project/new_file.txt

Verá un evento DELETE. Esta retroalimentación en tiempo real es invaluable para un Centro de Operaciones de Seguridad (SOC) o un sistema de detección de intrusiones automatizado.

/home/labex/project/ DELETE new_file.txt

Para detener el proceso de monitoreo en segundo plano, puede usar el comando pkill.

pkill inotifywait

Ha utilizado con éxito tanto find como inotifywait para detectar cambios en el sistema de archivos.

Analizar Registros del Sistema en Busca de Entradas Anómalas

En este paso, aprenderá a analizar los registros del sistema para encontrar evidencia de actividad sospechosa. Los registros del sistema son registros de eventos que ocurren en el sistema y son una fuente crítica de información para el monitoreo de seguridad y el análisis forense. Nos centraremos en los registros de autenticación, que rastrean los inicios de sesión de usuarios y las escaladas de privilegios, y utilizaremos herramientas estándar de Linux como grep, tail y journalctl para encontrar entradas anómalas.

La mayoría de los registros del sistema en un sistema Linux se almacenan en el directorio /var/log. Uno de los más importantes para la seguridad es /var/log/auth.log, que registra eventos relacionados con la autenticación, incluidos los inicios de sesión SSH y el uso del comando sudo. Comencemos visualizando las últimas líneas de este archivo usando el comando tail. Necesita sudo porque este archivo está protegido.

sudo tail /var/log/auth.log

Verá una serie de entradas con marcas de tiempo. El formato típicamente incluye la fecha, hora, nombre del host, el proceso que generó el registro y el mensaje del evento.

Jul 22 10:30:01 labex-vm sudo:    labex : TTY=pts/0 ; PWD=/home/labex/project ; USER=root ; COMMAND=/usr/bin/tail /var/log/auth.log
Jul 22 10:30:01 labex-vm sudo: pam_unix(sudo:session): session opened for user root(uid=0) by (uid=1000)
Jul 22 10:30:01 labex-vm sudo: pam_unix(sudo:session): session closed for user root

Ahora, simulemos un evento sospechoso común: un intento de inicio de sesión fallido. Los atacantes a menudo intentan adivinar contraseñas para nombres de usuario válidos o comunes. Podemos simular esto intentando conectarnos por SSH a nuestra propia máquina (localhost) con un nombre de usuario que no existe, como baduser.

ssh baduser@localhost

El sistema le pedirá una contraseña (puede usar labex como contraseña). Dado que el usuario no existe, cualquier contraseña fallará. Simplemente presione Ctrl+C para cancelar la solicitud de contraseña y regresar a la terminal. El intento de conexión fallará, pero se registrará.

Ahora, busquemos la evidencia. Podemos usar el comando grep para filtrar el archivo auth.log en busca de líneas que contengan la palabra "Failed". Esto aísla rápidamente los eventos infructuosos.

sudo grep "Failed" /var/log/auth.log

La salida ahora mostrará claramente la entrada de registro de nuestro intento de inicio de sesión SSH fallido, que es un fuerte indicador de un posible intento de intrusión.

Jul 22 10:35:15 labex-vm sshd[12345]: Failed password for invalid user baduser from 127.0.0.1 port 54321 ssh2

Los sistemas Linux modernos que utilizan systemd también tienen un sistema de registro centralizado administrado por journald. El comando journalctl es una herramienta potente para consultar estos registros. Usemoslo para encontrar el mismo evento de inicio de sesión fallido buscando mensajes del proceso sshd. Tenga en cuenta que debe usar sudo para ver los registros a nivel del sistema.

sudo journalctl | grep sshd

Desplácese por la salida (usando las teclas de flecha, y presione q para salir) y encontrará la misma entrada "Failed password". Para que sea aún más fácil, puede filtrar por prioridad del mensaje. Pidamos a journalctl que muestre solo las entradas con una prioridad de "error" (err) o superior para el servicio sshd.

sudo journalctl -p err | grep sshd

Este comando le brinda una vista mucho más concisa solo de las condiciones de error, lo que lo hace muy eficiente para detectar problemas.

-- Logs begin at ... --
Jul 22 10:35:15 labex-vm sshd[12345]: Failed password for invalid user baduser from 127.0.0.1 port 54321 ssh2
-- End of logs --

Finalmente, también puede inyectar manualmente mensajes en los registros usando el comando logger. Esto es útil para que los scripts personalizados informen sobre eventos de seguridad. Creemos una alerta personalizada.

logger "SECURITY-ALERT: Unauthorized file access detected in /etc"

Ahora, busque esta alerta específica en los registros del sistema.

sudo grep "SECURITY-ALERT" /var/log/syslog

Verá su mensaje personalizado, lo que demuestra cómo puede integrar su propio monitoreo con la instalación de registro del sistema.

Jul 22 10:40:00 labex-vm labex: SECURITY-ALERT: Unauthorized file access detected in /etc

Ahora ha aprendido los conceptos básicos de navegación por los registros del sistema para encontrar evidencia de actividad anómala y potencialmente maliciosa.

Resumen

En este laboratorio, aprendió técnicas esenciales para identificar indicadores de malware en un sistema Linux. Practicó cómo observar la actividad sospechosa de procesos utilizando el comando top para monitorear picos anormales de CPU y memoria. Para comprender cómo se ve esto en un escenario del mundo real, utilizó la utilidad stress para simular un proceso de alta carga y comparó su consumo de recursos con una línea base normal del sistema.

El laboratorio también cubrió cómo detectar creaciones y modificaciones de archivos inesperadas, que son signos comunes de un sistema comprometido. Finalmente, aprendió a analizar los registros del sistema en busca de entradas anómalas, una habilidad crucial para encontrar evidencia de acceso no autorizado, configuraciones erróneas u otros eventos relacionados con la seguridad.