Análise de Malware

Reading time: 10 minutes

CheatSheets de Forense

https://www.jaiminton.com/cheatsheet/DFIR/#

Serviços Online

• VirusTotal
• HybridAnalysis
• Koodous
• Intezer
• Any.Run

Ferramentas Offline de Antivírus e Detecção

Yara

Instalação

sudo apt-get install -y yara

Preparar regras

Use este script para baixar e mesclar todas as yara malware rules do github: https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9
Crie o diretório rules e execute-o. Isso criará um arquivo chamado malware_rules.yar que contém todas as yara rules para malware.

wget https://gist.githubusercontent.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9/raw/4ec711d37f1b428b63bed1f786b26a0654aa2f31/malware_yara_rules.py
mkdir rules
python malware_yara_rules.py

Varredura

yara -w malware_rules.yar image  #Scan 1 file
yara -w malware_rules.yar folder #Scan the whole folder

YaraGen: Verificar malware e criar regras

Você pode usar a ferramenta YaraGen para gerar yara rules a partir de um binário. Confira estes tutoriais: Part 1, Part 2, Part 3

python3 yarGen.py --update
python3.exe yarGen.py --excludegood -m  ../../mals/

ClamAV

Instalação

sudo apt-get install -y clamav

Varredura

sudo freshclam      #Update rules
clamscan filepath   #Scan 1 file
clamscan folderpath #Scan the whole folder

Capa

Capa detecta potencialmente maliciosas capabilities em executáveis: PE, ELF, .NET. Assim, irá encontrar coisas como Att&ck tactics, ou capacidades suspeitas como:

• check for OutputDebugString error
• run as a service
• create process

Obtenha-o no Github repo.

IOCs

IOC significa Indicador de Comprometimento. Um IOC é um conjunto de condições que identificam algum software potencialmente indesejado ou confirmado malware. Blue Teams usam esse tipo de definição para procurar por esse tipo de arquivos maliciosos em seus sistemas e redes.
Compartilhar essas definições é muito útil, pois quando malware é identificado em um computador e um IOC para esse malware é criado, outras Blue Teams podem usá-lo para identificar o malware mais rapidamente.

Uma ferramenta para criar ou modificar IOCs é IOC Editor.
Você pode usar ferramentas como Redline para buscar IOCs definidos em um dispositivo.

Loki

Loki é um scanner para Indicadores Simples de Comprometimento.
A detecção baseia-se em quatro métodos de detecção:

1. File Name IOC
Regex match on full file path/name

2. Yara Rule Check
Yara signature matches on file data and process memory

3. Hash Check
Compares known malicious hashes (MD5, SHA1, SHA256) with scanned files

4. C2 Back Connect Check
Compares process connection endpoints with C2 IOCs (new since version v.10)

Linux Malware Detect

Linux Malware Detect (LMD) é um scanner de malware para Linux lançado sob a licença GNU GPLv2, projetado para as ameaças enfrentadas em ambientes de hospedagem compartilhada. Ele usa dados de ameaça de sistemas de detecção de intrusão de borda de rede para extrair malware que está sendo usado ativamente em ataques e gera assinaturas para detecção. Além disso, dados de ameaça também são derivados de submissões de usuários com o recurso checkout do LMD e de recursos da comunidade de malware.

rkhunter

Ferramentas como rkhunter podem ser usadas para verificar o sistema de arquivos em busca de possíveis rootkits e malware.

sudo ./rkhunter --check -r / -l /tmp/rkhunter.log [--report-warnings-only] [--skip-keypress]

FLOSS

FLOSS é uma ferramenta que tenta encontrar strings ofuscadas dentro de executáveis usando diferentes técnicas.

PEpper

PEpper verifica algumas coisas básicas dentro do executável (dados binários, entropia, URLs e IPs, algumas yara rules).

PEstudio

PEstudio é uma ferramenta que permite obter informações de executáveis Windows, como imports, exports, headers, mas também verifica virus total e encontra potenciais técnicas Att&ck.

Detect It Easy(DiE)

DiE é uma ferramenta para detectar se um arquivo está encrypted e também encontrar packers.

NeoPI

NeoPI is um script Python que utiliza uma variedade de métodos estatísticos para detectar conteúdo ofuscado e criptografado em arquivos de texto/script. O objetivo do NeoPI é auxiliar na detecção de hidden web shell code.

php-malware-finder

PHP-malware-finder faz o possível para detectar código ofuscado/dodgy code, assim como arquivos que usam funções PHP frequentemente usadas em malwares/webshells.

Apple Binary Signatures

Ao verificar alguma malware sample você deve sempre checar a assinatura do binário, pois o developer que a assinou pode já estar relacionado com malware.

#Get signer
codesign -vv -d /bin/ls 2>&1 | grep -E "Authority|TeamIdentifier"

#Check if the app’s contents have been modified
codesign --verify --verbose /Applications/Safari.app

#Check if the signature is valid
spctl --assess --verbose /Applications/Safari.app

Técnicas de Detecção

Empilhamento de Arquivos

Se você sabe que alguma pasta contendo os arquivos de um servidor web foi atualizada pela última vez em certa data, verifique a data em que todos os arquivos no servidor web foram criados e modificados e, se alguma data for suspeita, investigue esse arquivo.

Baselines

Se os arquivos de uma pasta não deveriam ter sido modificados, você pode calcular o hash dos arquivos originais da pasta e compará-los com os atuais. Qualquer coisa modificada será suspeita.

Análise Estatística

Quando a informação é salva em logs, você pode verificar estatísticas, como quantas vezes cada arquivo do servidor web foi acessado — um web shell pode ser um dos mais acessados.

Telemetria nativa in-app no Android (sem root)

No Android, você pode instrumentar código nativo dentro do processo do app alvo pré-carregando uma pequena biblioteca de logger antes que outras libs JNI inicializem. Isso fornece visibilidade precoce do comportamento nativo sem hooks em nível de sistema ou root. Uma abordagem popular é SoTap: coloque libsotap.so para o ABI correto dentro do APK e injete uma chamada System.loadLibrary("sotap") cedo (por exemplo, inicializador estático ou Application.onCreate), depois colete logs de caminhos internos/externos ou use Logcat como fallback.

See the Android native reversing page for setup details and log paths:

Reversing Native Libraries

Desofuscação de Fluxo de Controle Dinâmico (JMP/CALL RAX Dispatchers)

Famílias modernas de malware abusam fortemente da obfuscação do Control-Flow Graph (CFG): em vez de um jump/call direto, elas calculam o destino em tempo de execução e executam um jmp rax ou call rax. Um pequeno dispatcher (tipicamente nove instruções) define o alvo final dependendo das flags da CPU ZF/CF, quebrando completamente a recuperação estática do CFG.

A técnica — demonstrada pelo loader SLOW#TEMPEST — pode ser derrotada com um fluxo de trabalho em três passos que depende apenas de IDAPython e do emulador de CPU Unicorn.

1. Localize cada jump / call indireto

import idautils, idc

for ea in idautils.FunctionItems(idc.here()):
mnem = idc.print_insn_mnem(ea)
if mnem in ("jmp", "call") and idc.print_operand(ea, 0) == "rax":
print(f"[+] Dispatcher found @ {ea:X}")

2. Extrair o byte-code do dispatcher

import idc

def get_dispatcher_start(jmp_ea, count=9):
s = jmp_ea
for _ in range(count):
s = idc.prev_head(s, 0)
return s

start = get_dispatcher_start(jmp_ea)
size  = jmp_ea + idc.get_item_size(jmp_ea) - start
code  = idc.get_bytes(start, size)
open(f"{start:X}.bin", "wb").write(code)

3. Emule-o duas vezes com Unicorn

from unicorn import *
from unicorn.x86_const import *
import struct

def run(code, zf=0, cf=0):
BASE = 0x1000
mu = Uc(UC_ARCH_X86, UC_MODE_64)
mu.mem_map(BASE, 0x1000)
mu.mem_write(BASE, code)
mu.reg_write(UC_X86_REG_RFLAGS, (zf << 6) | cf)
mu.reg_write(UC_X86_REG_RAX, 0)
mu.emu_start(BASE, BASE+len(code))
return mu.reg_read(UC_X86_REG_RAX)

Execute run(code,0,0) e run(code,1,1) para obter os alvos de branch false e true.

4. Patch back um jump / call direto

import struct, ida_bytes

def patch_direct(ea, target, is_call=False):
op   = 0xE8 if is_call else 0xE9           # CALL rel32 or JMP rel32
disp = target - (ea + 5) & 0xFFFFFFFF
ida_bytes.patch_bytes(ea, bytes([op]) + struct.pack('<I', disp))

Após patching, force o IDA a reanalisar a função para que o CFG completo e a saída do Hex-Rays sejam restaurados:

import ida_auto, idaapi
idaapi.reanalyze_function(idc.get_func_attr(ea, idc.FUNCATTR_START))

5. Rotular chamadas de API indiretas

Uma vez que o destino real de cada call rax seja conhecido, você pode dizer ao IDA qual é para que os tipos de parâmetros & nomes das variáveis sejam recuperados automaticamente:

idc.set_callee_name(call_ea, resolved_addr, 0)  # IDA 8.3+

Benefícios práticos

• Restaura o CFG real → a descompilação passa de 10 linhas para milhares.
• Permite string-cross-reference & xrefs, tornando a reconstrução do comportamento trivial.
• Scripts são reutilizáveis: coloque-os em qualquer loader protegido pelo mesmo truque.

AdaptixC2: Extração de Configuração e TTPs

Veja a página dedicada:

Adaptixc2 Config Extraction And Ttps

Referências

• Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques
• SoTap: Registrador leve de comportamento in-app JNI (.so) – github.com/RezaArbabBot/SoTap
• Unit42 – AdaptixC2: A New Open-Source Framework Leveraged in Real-World Attacks