Introducción
En este laboratorio, aprenderás cómo los atacantes mantienen un acceso persistente y evaden la detección básica. Si bien los marcos automatizados como Metasploit utilizan Meterpreter para migrar cargas útiles sin problemas a procesos estables de Windows (como explorer.exe o svchost), los entornos Linux requieren un enfoque diferente.
El principio general es independiente de la plataforma: los atacantes prefieren esconderse dentro de contextos de ejecución de larga duración y apariencia común en lugar de aquellos que son inestables o obviamente sospechosos.
En Linux, los atacantes logran los mismos objetivos de evasión identificando procesos estables del sistema y utilizando la "suplantación de nombres de procesos" (Process Name Spoofing) para disfrazar sus cargas útiles maliciosas. Aprenderás a realizar el reconocimiento de los procesos en ejecución, identificar componentes confiables del sistema y ejecutar una carga útil que se hace pasar por un hilo del kernel legítimo para evadir la detección.
Esto tiene que ver tanto con la estabilidad como con la percepción humana. Los defensores que observan grandes listas de procesos tienen más probabilidades de pasar por alto nombres que se mezclan con el ruido esperado del sistema.
Ver procesos en ejecución (ps)
En este paso, aprenderás a listar y analizar los procesos en ejecución en un sistema Linux. Los atacantes utilizan esta fase de reconocimiento para comprender el entorno y encontrar procesos legítimos que puedan suplantar.
Nuevamente, la enumeración es lo primero. No puedes elegir un proceso de camuflaje creíble si no sabes cómo se ve lo "normal" en el host.
El comando ps (estado del proceso) es la herramienta estándar para ver los procesos activos. Para obtener una vista completa de todos los procesos que se ejecutan en el sistema, puedes usar las banderas aux.
Ejecuta el siguiente comando en tu terminal para ver los procesos en ejecución:
ps aux | head -n 15
La bandera a muestra los procesos de todos los usuarios, u muestra el formato orientado al usuario (incluido el uso de CPU y memoria), y x muestra los procesos que no están conectados a una terminal. Enviamos la salida a head -n 15 para mostrar solo las primeras 15 líneas, manteniendo la salida manejable.
Deberías ver una salida similar a esta:
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.1 167008 11468 ? Ss 10:00 0:01 /sbin/init
root 2 0.0 0.0 0 0 ? S 10:00 0:00 [kthreadd]
root 3 0.0 0.0 0 0 ? I< 10:00 0:00 [rcu_gp]
root 4 0.0 0.0 0 0 ? I< 10:00 0:00 [rcu_par_gp]
root 5 0.0 0.0 0 0 ? I< 10:00 0:00 [slub_flushwq]
root 6 0.0 0.0 0 0 ? I< 10:00 0:00 [netns]
root 8 0.0 0.0 0 0 ? I< 10:00 0:00 [kworker/0:0H-events_highpri]
root 10 0.0 0.0 0 0 ? I< 10:00 0:00 [mm_percpu_wq]
root 11 0.0 0.0 0 0 ? S 10:00 0:00 [rcu_tasks_rude_]
root 12 0.0 0.0 0 0 ? S 10:00 0:00 [rcu_tasks_trace]
root 13 0.0 0.0 0 0 ? S 10:00 0:00 [ksoftirqd/0]
root 14 0.0 0.0 0 0 ? I 10:00 0:00 [rcu_sched]
root 15 0.0 0.0 0 0 ? S 10:00 0:00 [migration/0]
root 16 0.0 0.0 0 0 ? S 10:00 0:00 [idle_inject/0]
Observa los procesos encerrados entre corchetes, como [kthreadd] o [kworker/0:0H-events_highpri]. Estos son hilos del kernel. Son altamente estables, se ejecutan continuamente y rara vez son inspeccionados por los administradores del sistema, lo que los convierte en candidatos perfectos para la evasión.
Identificar procesos objetivo estables
En este paso, identificarás procesos específicos que son ideales para la evasión. Un proceso estable suele ser un demonio del sistema o un servicio de escritorio que se inicia automáticamente y sigue ejecutándose durante mucho tiempo.
Si la carga útil de un atacante falla, pierde el acceso. Al disfrazar su carga útil como un proceso estable, evitan levantar sospechas. En algunos entornos Linux, las entradas kworker son fáciles de observar y constituyen un modelo de nomenclatura conveniente porque sus nombres parecen técnicos y se mezclan en largas listas de procesos.
Comprobemos si este entorno muestra nombres al estilo kworker. Ejecuta el siguiente comando:
ps -ef | grep kworker | head -n 5
La bandera -e selecciona todos los procesos y -f realiza un listado de formato completo. Usamos grep para filtrar solo las líneas que contienen "kworker".
Si el entorno expone entradas de trabajadores del kernel, es posible que veas una salida similar a esta:
root 8 2 0 10:00 ? 00:00:00 [kworker/0:0H-events_highpri]
root 25 2 0 10:00 ? 00:00:00 [kworker/1:0H-events_highpri]
root 31 2 0 10:00 ? 00:00:00 [kworker/2:0H-events_highpri]
root 37 2 0 10:00 ? 00:00:00 [kworker/3:0H-events_highpri]
root 43 2 0 10:00 ? 00:00:00 [kworker/0:1-events]
Si solo ves el comando grep y no hay entradas reales de kworker, es aceptable en este entorno de laboratorio. Seguiremos utilizando el estilo de nomenclatura familiar [kworker/X:Y] en el siguiente paso porque el objetivo es aprender cómo funciona la suplantación de nombres de procesos, no depender de que un hilo del kernel específico sea visible.
Migrar a un proceso estable
En este paso, simularás la migración de procesos iniciando un proceso de larga duración y suplantando su nombre.
Se ha preparado una carga útil ficticia llamada malicious_payload.sh para ti en ~/project, pero hay un detalle importante de Linux aquí. Cuando ejecutas un script de shell, la lista de procesos generalmente muestra el intérprete, como /bin/bash /home/labex/project/malicious_payload.sh. Ese comportamiento hace que el nombre suplantado sea difícil de observar claramente en este entorno.
Para que la suplantación sea fácil de verificar, utilizaremos un comando simple de larga duración en su lugar. El concepto de seguridad sigue siendo el mismo: le estamos dando a un proceso un nombre visible engañoso para que se mezcle en la lista de procesos.
Ejecuta el siguiente comando para iniciar un proceso en segundo plano disfrazado:
bash -c 'exec -a "[kworker/u4:2]" sleep 600' &
La parte bash -c inicia un nuevo proceso de Bash y ejecuta la cadena de comando que sigue. exec -a "[kworker/u4:2]" reemplaza ese proceso de Bash con sleep 600, pero le indica al sistema operativo que muestre el nombre del proceso como [kworker/u4:2]. El comando sleep 600 mantiene el proceso vivo el tiempo suficiente para que lo inspecciones. El & al final ejecuta el proceso en segundo plano.
Verás una pequeña salida que indica el número de trabajo en segundo plano y el ID del proceso (PID), similar a:
[1] 1337
Tu proceso disfrazado ahora se está ejecutando silenciosamente en segundo plano y debería aparecer con el nombre suplantado.
Verificar persistencia y acceso
En este paso final, verificarás que tu proceso disfrazado sea visible bajo su identidad suplantada y luego lo limpiarás.
Busca el nombre suplantado que asignaste en el paso anterior:
ps aux | grep "kworker/u4:2"
Deberías ver una salida similar a esta:
labex 1337 0.0 0.0 7008 1536 pts/0 S 10:15 0:00 [kworker/u4:2]
labex 1345 0.0 0.0 6480 2272 pts/0 S+ 10:16 0:00 grep --color=auto kworker/u4:2
En este entorno, el proceso disfrazado es solo una demostración creada con sleep, no un trabajador del kernel real. El punto importante es que el nombre visible en la lista de procesos ahora parece un componente confiable del sistema.
Finalmente, limpia el proceso de demostración terminando la línea de comando que contiene el nombre suplantado. Ejecuta el siguiente comando:
pkill -f "kworker/u4:2"
Puedes ejecutar ps aux | grep "kworker/u4:2" una vez más para confirmar que el proceso disfrazado ha sido terminado con éxito.
Resumen
¡Felicidades! Has completado con éxito el laboratorio de Migración de procesos y evasión.
Has aprendido cómo los atacantes analizan los procesos en ejecución para identificar componentes del sistema estables y confiables. También aprendiste a usar la suplantación de nombres de procesos (exec -a) para disfrazar una carga útil maliciosa como un hilo del kernel legítimo, simulando eficazmente las técnicas de evasión utilizadas por marcos avanzados como Meterpreter. Finalmente, verificaste el sigilo del proceso suplantado y aprendiste cómo terminarlo correctamente. Estas habilidades son esenciales para comprender cómo las amenazas persistentes se esconden dentro de un entorno Linux.
