Linode Security Digest 23-30 de janeiro de 2022

Esta semana, vamos cobrir um novo espécime de malware chamado Sysjoker e um guia para forenses de memória Linux. Embora o guia forense não seja abrangente e certamente não esteja em todos os detalhes, ele pode ajudar a entender o básico de um processo de extração e análise de memória usando a Volatilidade.

Sysjoker Backdoor

Em um recente postagem por Intezeros autores analisaram uma nova porta traseira capaz de funcionar em múltiplos sistemas operacionais. De acordo com a análise, "Sysjoker" pode rodar em macOS, Linux, e Windows. Sysjoker se esconde como uma atualização do sistema e usa diferentes métodos para esconder e mudar o endereço IP de seu servidor de Comando e Controle (C2).

Também é preocupante o fato de a amostra ter vindo limpa das varreduras VirusTotal, o que pode indicar que a porta traseira é bastante nova. Embora os métodos utilizados para infectar um sistema sejam diferentes em vários sistemas operacionais, uma vez que ele ganha persistência em um sistema, ele começa a se comunicar com o servidor C2. Na análise, o Intezer afirma que ainda não viu uma próxima etapa de instrução do servidor C2. O post sugere o uso de scanners de memória para detectar o malware.

Outra forma de fazer análise forense é descarregar a memória e analisá-la com uma ferramenta bem conhecida como a Volatilidade. Nas versões mais antigas do kernel Linux, o despejo da memória podia ser feito copiando a memória virtual de /dev/mem usando uma ferramenta de linha de comando como a dd; no entanto, este método foi depreciado devido a possíveis implicações de segurança. 

Memória Linux Forense

Podemos resumir a análise forense como os diferentes métodos usados na aquisição de provas, análise de provas e documentação das conseqüências de um incidente de segurança. Após uma violação de segurança confirmada, uma análise forense geralmente ocorre para entender melhor o que aconteceu em um sistema comprometido. Há inúmeras fontes de evidência que você pode analisar para fazer alegações defensáveis sobre a fonte de um incidente; entretanto, faremos apenas uma análise prática da memória de um sistema Linux comprometido para demonstrar algumas das metodologias e ferramentas que você pode usar.

Memória

A RAM, por natureza, é volátil. Ela requer energia constante para passar por ela para funcionar, e é reinicializada toda vez que um sistema é reinicializado. O Linux mantém os dados armazenados na memória sob o diretório /dev/mem; entretanto, é impossível extrair artefatos da memória usando esta partição diretamente em distribuições mais recentes. Isto porque a partir do kernel Linux 4.16, uma opção(CONFIG_STRICT_DEVMEM) é habilitada por padrão para desativar o acesso a esta partição sensível. 

Embora isto dificulte a aquisição da imagem da memória, também torna mais difícil para os adversários (e usuários inexperientes) causar danos devastadores ao sistema. Um atacante com acesso root ao sistema pode usar o dispositivo mem para injetar código diretamente no kernel se esta opção for desativada.

Para esta demonstração, nós criamos um Linode Debian 9 com o nome de "forense" em um de nossos centros de dados. Configuramos a caixa forense para ser um exemplo de um ambiente de construção e análise. Embora não seja necessário fazer isso em uma máquina externa, é desaconselhável adulterar um computador que contenha provas. Aqui estão os passos para nossa análise:

1. Criar um perfil de Volatilidade para um sistema comprometido usando uma máquina com o mesmo SO e kernel build/version.
2. Despeje a memória com a ferramenta de sua escolha (AVML nesta demonstração).
3. Inspecione a memória despejada usando o perfil que você criou para Volatilidade com a ajuda de plugins.

Advertência

Utilizaremos o repositório de Volatilidade Python 2 para fins de demonstração, devido às questões de compatibilidade atualmente em andamento com a Volatilidade 3. Estamos cientes de que o apoio ao Python 2 terminou em 2020; isto é estritamente para demonstrar o uso da ferramenta em um ambiente controlado. Se você gostaria de seguir junto com o guia, por favor, faça-o por sua própria conta e risco.

Requisitos

Por padrão, Debian 9 Linodes não terá algumas das ferramentas que vamos utilizar nesta demonstração. É recomendável instalar todas elas com o seguinte comando antes de proceder com outras instruções:

sudo apt install make git zip dwarfdump linux-headers-$(uname -r) python-pip python-distorm3 python-crypto

Volatilidade

O Volatility Framework é uma coleção completamente aberta de ferramentas implementadas em Python sob a Licença Pública Geral GNU para extrair artefatos digitais de amostras de memória volátil (RAM).

É importante garantir que o perfil de volatilidade correto seja usado ao analisar um depósito de memória. Um perfil é um arquivo que contém informações sobre a estrutura de dados de um kernel e símbolos de depuração que podem ser usados para analisar corretamente uma imagem de memória. Felizmente, a criação de um perfil com Volatilidade é bastante simples. Você também pode verificar o repositório de perfis de Volatilidade para alguns perfis pré-construídos.

Construindo um perfil

Depois de instalar as ferramentas necessárias, podemos começar a construir nosso perfil de Volatilidade para a máquina na qual ela está funcionando.

1. git clone https://github.com/volatilityfoundation/volatility ~/volatility
2. cd ~/volatility/tools/linux/
3. make
4. zip ~/$(lsb_release -i -s)_$(uname -r).zip ./module.dwarf /boot/System.map-$(uname -r)
5. cp ~/$(lsb_release -i -s)_$(uname -r).zip ~/volatility/volatility/plugins/overlays/linux/
6. python ~/volatility/vol.py --info

A linha inicial (1) clonará o repositório de Volatilidade no diretório home do usuário. Ao entrar no diretório (2) ~/volatility/tools/linux, podemos usar o make (3) para recompilar os módulos do kernel. É importante ter os cabeçalhos do kernel baixados com antecedência, caso contrário, este processo pode falhar. 

Isto resulta em um module.dwarf. Então o próximo comando (4) usa este módulo para ler o mapa do sistema de /boot para gerar o perfil que precisamos usar em Volatilidade. Podemos então copiar este perfil (5) para o diretório correto, para que o Volatility possa usá-lo. Finalmente, para verificar se nosso perfil está devidamente carregado em Volatilidade, podemos executar Volatilidade uma vez com a bandeira de informação (6). Se todas as etapas forem bem sucedidas, devemos ver nosso perfil personalizado na seção Perfis da saída.

Instalação de um módulo de núcleo oculto

Para este exemplo, usamos o HiddenWall para gerar um Módulo Kernel Linux oculto (LKM), denominado 'cantfindme', e o carregamos em outro Debian 9 Linode com a mesma construção/versão do kernel que a máquina 'forense'. Embora o módulo seja carregado, ele não pode ser visto quando lsmod ou modprobe é executado no sistema: 

Aquisição de memória

Há grandes ferramentas que você pode usar para despejar a memória no Linux; entretanto, neste guia, iremos com AVML (Acquire Volatile Memory for Linux), uma vez que o LiME é coberto freqüentemente na web. AVML é uma ferramenta de aquisição de memória open-source para Linux feita pela Microsoft. Você pode encontrar o último lançamento aqui e baixar o binário para a máquina da qual você quer descarregar a memória. Lembre-se que o computador de onde estamos despejando a memória deve ter o mesmo kernel/OS build e versão que o perfil de Volatilidade que geramos anteriormente.

Em um cenário real, é importante não mexer em um sistema comprometido para garantir que as provas que coletamos possam ser admissíveis em um tribunal. Também é importante não comprimir nenhuma imagem sempre que possível, pois a aquisição bit a bit pode fornecer dados que uma imagem comprimida não pode.

Após baixar o binário AVML no diretório home, você pode usar o seguinte comando para descarregar a memória de um sistema para o diretório home.

sudo ~/avml ~/output.lime

A AVML irá despejar a memória no formato LiME, para que possamos iniciar nossa análise com o perfil de Volatilidade que criamos. Você também pode verificar o tamanho do despejo para garantir que ele corresponda ao total de RAM do dispositivo. A volatilidade não deve interferir com o despejo de memória, mas é melhor fazer uma cópia do arquivo e analisar os dados copiados em vez dos originais depois de garantir que seus hashes coincidam.

Depois de despejar a memória da caixa 'pwnd', transferimo-la para a caixa 'forense' para análise.

Plugins de Volatilidade

A volatilidade oferece numerosos plugins para auxiliar o analista forense. Você pode encontrar uma lista desses plugins em sua página do Github. Usando os plugins Volatility, podemos obter uma rápida visão geral da imagem da memória. O formato de comando para análise de uma imagem de memória pode ser encontrado abaixo:

python ~/volatility/vol.py -f <path_to_memory_dump> --profile=<profile>
<plugin_name> <plugin_options>

Aqui está a saída do plugin linux_hidden_modules que lista os módulos de kernel carregados ocultos da imagem da memória:

Este plugin pode ajudá-lo a encontrar Módulos de Kernel Linux ocultos que podem ser maliciosos. Mesmo quando estes módulos não podem ser vistos quando você executa lsmod no sistema, ambos podem ser detectados e extraídos de um despejo de memória. Você pode usar o plugin linux_moddump para descarregar os módulos do kernel especificando seu nome em um padrão regex ou especificando o endereço base do módulo na imagem da memória:

Há mais coisas que podem ser feitas com Volatilidade que simplesmente não podemos cobrir neste posto. Sinta-se à vontade para deixar um comentário abaixo para compartilhar suas idéias e sugestões.