Desofuscando Malware PowerShell Ofuscado

Visão Geral

O PowerShell é amplamente abusado por autores de malware devido à sua profunda integração com o Windows e poderosas capacidades de script. As técnicas de ofuscação incluem concatenação de strings, codificação Base64, substituição de caracteres, camadas de Invoke-Expression, abuso de SecureString, manipulação de variáveis de ambiente e inserção de crases. Malware moderno usa múltiplas camadas de ofuscação que exigem desofuscação iterativa. Ferramentas como PSDecode, PowerDecode e PowerPeeler automatizam grande parte desse processo, enquanto a análise manual da AST (Abstract Syntax Tree) lida com ofuscação personalizada. O PowerPeeler atinge uma taxa de correção de desofuscação de 95% usando análise dinâmica em nível de instrução de nós AST relacionados a expressões.

Quando Usar

• Ao realizar testes de segurança autorizados que envolvam a desofuscação de malware PowerShell ofuscado
• Ao analisar amostras de malware ou artefatos de ataque em um ambiente controlado
• Ao conduzir exercícios de equipe vermelha ou engajamentos de teste de penetração
• Ao construir capacidades de detecção com base na compreensão de técnicas ofensivas

Pré-requisitos

• Python 3.9+ com base64, re, subprocess módulos
• PowerShell 5.1+ ou PowerShell 7+ (para acesso à AST)
• PSDecode (Install-Module PSDecode)
• PowerDecode (https://github.com/Malandrone/PowerDecode)
• VM isolada ou sandbox para execução segura de scripts
• CyberChef para transformações manuais de codificação
• Compreensão da AST do PowerShell e padrões de Invoke-Expression

Conceitos Chave

Técnicas Comuns de Ofuscação

Malware PowerShell emprega ofuscação em camadas para evadir detecção estática. A concatenação de strings divide comandos entre variáveis ($a='In'+'voke'). A codificação Base64 envolve scripts inteiros em parâmetros -EncodedCommand. Arrays de códigos de caracteres usam casting [char] ([char[]](73,69,88)|%{$r+=$_}). O abuso de variáveis de ambiente lê substrings de caminhos $env:. A inserção de crases adiciona crases entre caracteres que o PowerShell ignora (Invoke-Expression`). A conversão de SecureString criptografa strings usando ConvertTo-SecureString com chaves embutidas.

Desofuscação Baseada em AST

A Abstract Syntax Tree do PowerShell expõe a estrutura analisada de scripts, independentemente da ofuscação de superfície. Ao percorrer a AST e avaliar nós de expressão, os analistas podem resolver strings concatenadas, decodificar valores codificados e reconstruir os comandos originais. O PowerPeeler usa essa abordagem em nível de instrução, monitorando o processo de execução para correlacionar nós AST com seus resultados avaliados.

Rastreamento de Execução Dinâmica

Ao substituir Invoke-Expression (IEX) por Write-Output, os analistas podem capturar com segurança o conteúdo do script desofuscado que normalmente seria executado. Essa técnica funciona em múltiplas camadas, substituindo iterativamente chamadas IEX até que o payload final seja revelado.

Fluxo de Trabalho

Etapa 1: Identificar Camadas de Ofuscação

#!/usr/bin/env python3
"""Identifica e classifica técnicas de ofuscação do PowerShell."""
import re
import base64
import sys


def analyze_obfuscation(script_content):
    """Identifica técnicas de ofuscação usadas em scripts do PowerShell."""
    techniques = []

    # Verifica comando codificado em Base64
    b64_pattern = re.compile(
        r'-[Ee](?:nc(?:odedcommand)?)\s+([A-Za-z0-9+/=]{20,})',
        re.IGNORECASE
    )
    if b64_pattern.search(script_content):
        techniques.append("Comando Codificado em Base64")

    # Verifica FromBase64String
    if re.search(r'\[Convert\]::FromBase64String', script_content, re.IGNORECASE):
        techniques.append("FromBase64String Base64")

    # Verifica concatenação de strings
    concat_count = script_content.count("'+'") + script_content.count('"+"')
    if concat_count > 3:
        techniques.append(f"Concatenação de Strings ({concat_count} junções)")

    # Verifica construção de array de caracteres
    if re.search(r'\[char\]\s*\d+', script_content, re.IGNORECASE):
        techniques.append("Array de Código de Caracteres")

    # Verifica variantes de Invoke-Expression
    iex_patterns = [
        r'Invoke-Expression',
        r'\bIEX\b',
        r'\.\s*\(\s*\$',
        r'&\s*\(\s*\$',
        r'\|\s*IEX',
        r'\|\s*Invoke-Expression',
    ]
    for pattern in iex_patterns:
        if re.search(pattern, script_content, re.IGNORECASE):
            techniques.append(f"Variante Invoke-Expression: {pattern}")

    # Verifica ofuscação com crase
    tick_count = script_content.count('`')
    if tick_count > 5:

…