Utilização de macros obfuscados em Excel para distribuir malware

Ghostwriter: Campanha Belarusiana utiliza macros obfuscados em Excel para distribuir malware

Ataques cibernéticos vinculados a grupos de ameaças associados à Belarus continuam a visar ativistas da oposição e entidades governamentais ucranianas. Recentemente, pesquisadores da SentinelOne identificaram uma nova campanha utilizando documentos maliciosos do Excel com macros obfuscados para distribuir uma variante do malware PicassoLoader.

O grupo, conhecido como Ghostwriter (TA445, UNC1151), está ativo desde 2016 e tem alinhamento com interesses de segurança russos. A campanha atual, em andamento desde meados de 2024, utiliza técnicas sofisticadas de evasão, incluindo Macropack para ofuscar macros VBA e ConfuserEx para embaralhar código .NET.

Neste artigo, exploramos a ameaça e apresentamos dois scripts em Python que podem ajudar na mitigação de ataques similares.

Técnicas utilizadas pelo Ghostwriter

• Macros obfuscados em Excel

  • Os atacantes distribuem arquivos Excel maliciosos via Google Drive ou e-mails de phishing.

  • As macros, ofuscadas com Macropack, são ativadas quando a vítima habilita o conteúdo.

  • Um arquivo DLL é escrito no disco, carregando o PicassoLoader ou outros payloads.

• Download de Payloads Adicionais

  • Após a infecção inicial, um arquivo Excel legítimo é exibido como isca, enquanto malware secundário é baixado.

  • Em alguns casos, o malware é escondido em imagens JPG (esteganografia) para evitar detecção.

• Uso de LibCMD para Execução de Comandos

  • Uma DLL maliciosa chamada LibCMD é carregada na memória para executar comandos via cmd.exe.

Mitigação com Python

Abaixo, apresentamos dois scripts em Python que podem ajudar a detectar e mitigar ameaças similares às utilizadas pelo Ghostwriter.

1. Analisador de macros em arquivos Office (detecção de VBA malicioso)

import olefile
import re

def analyze_macros(file_path):
    try:
        ole = olefile.OleFileIO(file_path)
        if ole.exists('Macros/VBA'):
            print("[!] Macros encontradas no arquivo!")
            macro_data = ole.openstream('Macros/VBA').read().decode('latin-1')
            
            # Padrões suspeitos (obfuscação, shellcode, URLs)
            suspicious_patterns = [
                r"Shell\(", r"CreateObject\(", r"URLDownloadToFile",
                r"chr\(\d+\)", r"eval\(", r"Execute\("
            ]
            
            for pattern in suspicious_patterns:
                if re.search(pattern, macro_data, re.IGNORECASE):
                    print(f"[ALERTA] Padrão suspeito encontrado: {pattern}")
                    return True
        else:
            print("[+] Nenhuma macro detectada.")
        ole.close()
    except Exception as e:
        print(f"[ERRO] Falha ao analisar o arquivo: {e}")
    return False

# Uso:
file_path = "malicious_document.xlsm"
if analyze_macros(file_path):
    print("Arquivo potencialmente malicioso! Investigação necessária.")
else:
    print("Arquivo parece seguro.")

Como funciona?

• Extrai e analisa macros de arquivos Office (Excel, Word).
• Busca por padrões suspeitos, como chamadas a Shell(), URLDownloadToFile, ou ofuscação com chr().

2. Monitoramento de processos suspeitos (detecção de cargas maliciosas em memória)

import psutil
import time

def monitor_suspicious_processes():
    suspicious_processes = ["cmd.exe", "powershell.exe", "wscript.exe", "mshta.exe"]
    malicious_dlls = ["LibCMD.dll", "PicassoLoader.dll"]
    
    while True:
        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
            try:
                # Verifica processos suspeitos
                if proc.info['name'] in suspicious_processes:
                    print(f"[ALERTA] Processo suspeito em execução: {proc.info}")
                
                # Verifica DLLs maliciosas carregadas
                for dll in malicious_dlls:
                    if dll.lower() in " ".join(proc.info['cmdline'] or []).lower():
                        print(f"[CRÍTICO] DLL maliciosa detectada: 
{dll} no PID {proc.info['pid']}")
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                continue
        time.sleep(5)  # Verifica a cada 5 segundos

# Uso:
print("Iniciando monitoramento de processos suspeitos...")
try:
    monitor_suspicious_processes()
except KeyboardInterrupt:
    print("Monitoramento encerrado.")

Como funciona?

• Monitora processos em execução, como cmd.exe ou powershell.exe, que podem ser usados para execução de payloads.

• Detecta carregamento de DLLs maliciosas conhecidas (ex: LibCMD.dll).

Conclusão

A campanha do Ghostwriter demonstra a sofisticação de grupos apoiados por Estados-nação, utilizando técnicas como obfuscação de macros e esteganografia para evadir detecção.

Com os scripts Python apresentados, equipes de segurança podem:

• Analisar automaticamente macros em documentos Office antes de abri-los.

• Monitorar processos em tempo real para detectar atividades maliciosas.

A mitigação proativa é essencial, especialmente para organizações ucranianas e ativistas que são alvos frequentes desses ataques.

Recomendações adicionais:

• Desabilitar macros por padrão no Microsoft Office.

• Utilizar sandboxing para análise de arquivos suspeitos.

• Monitorar tráfego de saída para domínios maliciosos (ex: sciencealert[.]shop).

Mantenha-se vigilante e atualize suas defesas continuamente!

Fonte e imagens: https://thehackernews.com/2025/02/belarus-linked-ghostwriter-uses.html