Introdução
Neste laboratório, você aprenderá como atacantes mantêm acesso persistente e evadem detecções básicas. Embora frameworks automatizados como o Metasploit usem o Meterpreter para migrar payloads perfeitamente para processos estáveis do Windows (como explorer.exe ou svchost), ambientes Linux exigem uma abordagem diferente.
O princípio geral é independente da plataforma: os atacantes preferem se esconder dentro de contextos de execução de longa duração e aparência comum, em vez de contextos instáveis ou obviamente suspeitos.
No Linux, os atacantes alcançam os mesmos objetivos de evasão identificando processos estáveis do sistema e usando a "Falsificação de Nome de Processo" (Process Name Spoofing) para disfarçar seus payloads maliciosos. Você aprenderá a realizar o reconhecimento de processos em execução, identificar componentes confiáveis do sistema e executar um payload que se mascara como uma thread de kernel legítima para evitar a detecção.
Isso envolve tanto a estabilidade quanto a percepção humana. Defensores que analisam grandes listas de processos tendem a ignorar nomes que se misturam ao ruído esperado do sistema.
Visualizar Processos em Execução (ps)
Nesta etapa, você aprenderá como listar e analisar processos em execução em um sistema Linux. Os atacantes usam essa fase de reconhecimento para entender o ambiente e encontrar processos legítimos que possam ser impersonados.
Novamente, a enumeração vem primeiro. Você não pode escolher um processo de camuflagem convincente se não souber como é o "normal" no host.
O comando ps (process status) é a ferramenta padrão para visualizar processos ativos. Para obter uma visão abrangente de todos os processos em execução no sistema, você pode usar as flags aux.
Execute o seguinte comando no seu terminal para visualizar os processos em execução:
ps aux | head -n 15
A flag a mostra processos de todos os usuários, u exibe o formato orientado ao usuário (incluindo uso de CPU e memória), e x mostra processos não conectados a um terminal. Direcionamos a saída para head -n 15 para exibir apenas as primeiras 15 linhas, mantendo a saída gerenciável.
Você verá uma saída semelhante 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]
Observe os processos entre colchetes, como [kthreadd] ou [kworker/0:0H-events_highpri]. Estas são threads de kernel. Elas são altamente estáveis, executam continuamente e raramente são inspecionadas por administradores de sistema, tornando-as candidatas perfeitas para evasão.
Identificar Processos Alvo Estáveis
Nesta etapa, você identificará processos específicos que são ideais para evasão. Um processo estável é tipicamente um daemon de sistema ou serviço de desktop que inicia automaticamente e permanece em execução por um longo período.
Se o payload de um atacante travar, ele perde o acesso. Ao disfarçar seu payload como um processo estável, ele evita levantar suspeitas. Em alguns ambientes Linux, as entradas kworker são fáceis de observar e constituem um modelo de nomenclatura conveniente, pois seus nomes parecem técnicos e se misturam em longas listas de processos.
Vamos verificar se este ambiente mostra nomes no estilo kworker. Execute o seguinte comando:
ps -ef | grep kworker | head -n 5
A flag -e seleciona todos os processos, e -f faz a listagem em formato completo. Usamos grep para filtrar apenas as linhas que contêm "kworker".
Se o ambiente expuser entradas de kernel worker, você poderá ver uma saída semelhante 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]
Se você vir apenas o comando grep e nenhuma entrada real de kworker, isso é aceitável neste ambiente de laboratório. Ainda usaremos o estilo de nomenclatura familiar [kworker/X:Y] na próxima etapa, pois o objetivo é aprender como a falsificação de nomes de processos funciona, e não depender da visibilidade de uma thread de kernel específica.
Migrar para um Processo Estável
Nesta etapa, você simulará a migração de processos iniciando um processo de longa duração e falsificando seu nome.
Um payload fictício chamado malicious_payload.sh foi preparado para você em ~/project, mas há um detalhe importante no Linux aqui. Quando você executa um script shell, a lista de processos geralmente mostra o interpretador, como /bin/bash /home/labex/project/malicious_payload.sh. Esse comportamento torna o nome falsificado difícil de observar claramente neste ambiente.
Para tornar a falsificação fácil de verificar, usaremos um comando simples de longa duração. O conceito de segurança permanece o mesmo: estamos dando a um processo um nome visível enganoso para que ele se misture à lista de processos.
Execute o seguinte comando para iniciar um processo em segundo plano disfarçado:
bash -c 'exec -a "[kworker/u4:2]" sleep 600' &
A parte bash -c inicia um novo processo Bash e executa a string de comando que a segue. exec -a "[kworker/u4:2]" substitui esse processo Bash por sleep 600, mas instrui o sistema operacional a exibir o nome do processo como [kworker/u4:2]. O comando sleep 600 mantém o processo vivo tempo suficiente para você inspecioná-lo. O & no final executa o processo em segundo plano.
Você verá uma pequena saída indicando o número do job em segundo plano e o ID do Processo (PID), semelhante a:
[1] 1337
Seu processo disfarçado agora está sendo executado silenciosamente em segundo plano e deve aparecer com o nome falsificado.
Verificar Persistência e Acesso
Nesta etapa final, você verificará se seu processo disfarçado está visível sob sua identidade falsificada e, em seguida, fará a limpeza.
Procure pelo nome falsificado que você atribuiu na etapa anterior:
ps aux | grep "kworker/u4:2"
Você deve ver uma saída semelhante 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
Neste ambiente, o processo disfarçado é apenas uma demonstração criada com sleep, não um kernel worker real. O ponto importante é que o nome visível na lista de processos agora parece um componente confiável do sistema.
Finalmente, limpe o processo de demonstração encerrando a linha de comando que contém o nome falsificado. Execute o seguinte comando:
pkill -f "kworker/u4:2"
Você pode executar ps aux | grep "kworker/u4:2" mais uma vez para confirmar que o processo disfarçado foi encerrado com sucesso.
Resumo
Parabéns! Você concluiu com sucesso o laboratório de Migração de Processos e Evasão.
Você aprendeu como atacantes analisam processos em execução para identificar componentes estáveis e confiáveis do sistema. Você também aprendeu a usar a falsificação de nomes de processos (exec -a) para disfarçar um payload malicioso como uma thread de kernel legítima, simulando efetivamente as técnicas de evasão usadas por frameworks avançados como o Meterpreter. Por fim, você verificou a furtividade do processo falsificado e aprendeu como encerrá-lo adequadamente. Essas habilidades são essenciais para entender como ameaças persistentes se escondem dentro de um ambiente Linux.
