Analisi del malware

Reading time: 10 minutes

Schede di riferimento Forensics

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

Servizi online

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

Strumenti antivirus e di rilevamento offline

Yara

Install

sudo apt-get install -y yara

Preparare le regole

Usa questo script per scaricare e unire tutte le regole yara per malware da github: https://gist.github.com/andreafortuna/29c6ea48adf3d45a979a78763cdc7ce9
Crea la directory rules ed esegui lo script. Questo creerà un file chiamato malware_rules.yar che contiene tutte le regole yara per malware.

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

Scansione

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

YaraGen: Controlla la presenza di malware e crea regole

Puoi usare lo strumento YaraGen per generare yara rules da un binary. Consulta questi tutorial: Part 1, Part 2, Part 3

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

ClamAV

Installazione

sudo apt-get install -y clamav

Scansione

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

Capa

Capa rileva potenzialmente capacità dannose negli eseguibili: PE, ELF, .NET. Quindi troverà cose come Att&ck tactics, o capacità sospette come:

• controllare l'errore OutputDebugString
• eseguire come servizio
• creare un processo

Scaricalo dal Github repo.

IOCs

IOC significa Indicator Of Compromise. Un IOC è un insieme di condizioni che identificano del software potenzialmente indesiderato o confermato malware. Le Blue Teams usano questo tipo di definizione per cercare questo tipo di file maligni nei loro sistemi e reti.
Condividere queste definizioni è molto utile: quando il malware viene identificato in un computer e viene creato un IOC per quel malware, altre Blue Teams possono usarlo per identificare il malware più rapidamente.

Uno strumento per creare o modificare gli IOC è IOC Editor.
Puoi usare strumenti come Redline per cercare IOCs definiti in un dispositivo.

Loki

Loki è uno scanner per Simple Indicators of Compromise.
La rilevazione si basa su quattro metodi di rilevamento:

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) è uno scanner di malware per Linux rilasciato sotto licenza GNU GPLv2, progettato per le minacce presenti negli ambienti hosting condivisi. Utilizza dati sulle minacce provenienti da network edge intrusion detection systems per estrarre il malware attivamente impiegato negli attacchi e genera firme per il rilevamento. Inoltre, i dati sulle minacce derivano anche dalle segnalazioni degli utenti tramite la funzionalità LMD checkout e dalle risorse della community del malware.

rkhunter

Strumenti come rkhunter possono essere usati per controllare il filesystem alla ricerca di possibili rootkits e malware.

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

FLOSS

FLOSS è uno strumento che tenta di trovare obfuscated strings all'interno di executables usando diverse tecniche.

PEpper

PEpper controlla alcune informazioni di base nell'executable (binary data, entropy, URLs and IPs, some yara rules).

PEstudio

PEstudio è uno strumento che permette di ottenere informazioni sui Windows executables come imports, exports, headers, ma controlla anche virus total e individua potenziali Att&ck techniques.

Detect It Easy(DiE)

DiE è uno strumento per rilevare se un file è encrypted e anche trovare packers.

NeoPI

NeoPI is a Python script che utilizza una varietà di statistical methods per rilevare contenuti obfuscated e encrypted all'interno di file di testo/script. Lo scopo di NeoPI è aiutare nella detection of hidden web shell code.

php-malware-finder

PHP-malware-finder fa del suo meglio per rilevare obfuscated/dodgy code così come file che utilizzano funzioni PHP spesso usate in malwares/webshells.

Apple Binary Signatures

Quando si analizza un malware sample dovresti sempre check the signature del binary, poiché il developer che lo ha firmato potrebbe essere già related con 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

Tecniche di rilevamento

File Stacking

Se sai che una cartella contenente i file di un web server è stata aggiornata l'ultima volta in una certa data, controlla la data in cui tutti i file nel web server sono stati creati e modificati e, se qualche data è sospetta, analizza quel file.

Linee di base

Se i file di una cartella non avrebbero dovuto essere modificati, puoi calcolare l'hash dei file originali della cartella e confrontarlo con quelli correnti. Qualsiasi modifica sarà sospetta.

Analisi statistica

Quando le informazioni sono salvate nei log puoi controllare statistiche come quante volte è stato accesso ciascun file del web server, poiché una web shell potrebbe essere uno dei file più accessi.

Android in-app native telemetry (no root)

Su Android, puoi strumentare codice nativo all'interno del processo dell'app target precaricando una piccola libreria logger prima che le altre librerie JNI vengano inizializzate. Questo fornisce visibilità precoce sul comportamento nativo senza hook di sistema o root. Un approccio popolare è SoTap: inserire libsotap.so per l'ABI corretto nell'APK e iniettare una chiamata System.loadLibrary("sotap") in fase iniziale (ad es., static initializer o Application.onCreate), quindi raccogliere i log da percorsi interni/esterni o usare Logcat come fallback.

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

Reversing Native Libraries

Deobfuscazione del controllo di flusso dinamico (JMP/CALL RAX Dispatchers)

Le famiglie di malware moderne abusano pesantemente dell'offuscamento del Control-Flow Graph (CFG): invece di un jump/call diretto calcolano la destinazione a runtime ed eseguono un jmp rax o call rax. Un piccolo dispatcher (tipicamente nove istruzioni) imposta il target finale a seconda dei flag della CPU ZF/CF, compromettendo completamente il recupero statico del CFG.

La tecnica — mostrata dal loader SLOW#TEMPEST — può essere neutralizzata con un flusso di lavoro in tre passaggi che si basa solamente su IDAPython e sull'emulatore CPU Unicorn.

1. Individuare ogni indirect jump / call

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. Estrai il byte-code del 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. Emulalo due volte con 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)

Esegui run(code,0,0) e run(code,1,1) per ottenere i target dei rami false e true.

4. Ripristinare tramite patch un jump / call diretto

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))

Dopo il patching, forza IDA a rianalizzare la funzione in modo che il CFG completo e l'output di Hex-Rays vengano ripristinati:

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

5. Etichettare le chiamate API indirette

Una volta che la destinazione reale di ogni call rax è nota, puoi indicare a IDA quale sia in modo che i tipi dei parametri e i nomi delle variabili vengano recuperati automaticamente:

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

Benefici pratici

• Ripristina il vero CFG → la decompilazione passa da 10 righe a migliaia.
• Abilita string-cross-reference & xrefs, rendendo la ricostruzione del comportamento semplice.
• Gli script sono riutilizzabili: inseriscili in qualsiasi loader protetto dallo stesso trick.

Riferimenti

• Unit42 – Evolving Tactics of SLOW#TEMPEST: A Deep Dive Into Advanced Malware Techniques
• SoTap: Lightweight in-app JNI (.so) behavior logger – github.com/RezaArbabBot/SoTap