Desofuscando Malware JavaScript

Quando Usar

• Investigando uma página de phishing com JavaScript ofuscado que realiza coleta de credenciais ou redirecionamento
• Analisando um web skimmer (estilo Magecart) injetado em um site de e-commerce
• Desofuscando um dropper JavaScript que baixa e executa malware de segundo estágio
• Examinando anexos de e-mail maliciosos contendo arquivos HTML com scripts ofuscados embutidos
• Analisando kits de exploração de navegador que usam ofuscação pesada de JavaScript para ocultar a entrega de exploits

Não use para JavaScript ofuscado que seja meramente código de produção minificado; use um beautifier padrão em vez disso.

Pré-requisitos

• Node.js 18+ instalado para executar e depurar JavaScript em um ambiente controlado
• Python 3.8+ com a biblioteca jsbeautifier para formatação de código
• Ferramentas de desenvolvedor do navegador (Chrome DevTools) para execução controlada em um navegador isolado
• CyberChef (https://gchq.github.io/CyberChef/) para operações de codificação/decodificação
• de4js ou JStillery para desofuscação automática de JavaScript
• VM de análise isolada sem acesso a sistemas de produção ou dados sensíveis

Fluxo de Trabalho

Passo 1: Extrair e Examinar o Script Ofuscado com Segurança

Isole o JavaScript malicioso sem executá-lo:

# Extract JavaScript from HTML file
python3 << 'PYEOF'
from html.parser import HTMLParser

class ScriptExtractor(HTMLParser):
    def __init__(self):
        super().__init__()
        self.in_script = False
        self.scripts = []
        self.current = ""

    def handle_starttag(self, tag, attrs):
        if tag == "script":
            self.in_script = True
            self.current = ""

    def handle_endtag(self, tag):
        if tag == "script":
            self.in_script = False
            if self.current.strip():
                self.scripts.append(self.current)

    def handle_data(self, data):
        if self.in_script:
            self.current += data

with open("malicious_page.html") as f:
    parser = ScriptExtractor()
    parser.feed(f.read())

for i, script in enumerate(parser.scripts):
    with open(f"script_{i}.js", "w") as f:
        f.write(script)
    print(f"Extracted script_{i}.js ({len(script)} bytes)")
PYEOF

# Beautify the extracted JavaScript
npx js-beautify script_0.js -o script_0_pretty.js

Passo 2: Identificar Técnicas de Ofuscação

Categorize os métodos de ofuscação utilizados:

Common JavaScript Obfuscation Techniques:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
String Encoding:
  - Hex encoding:          "\x68\x65\x6c\x6c\x6f" -> "hello"
  - Unicode escapes:       "\u0068\u0065\u006c\u006c\u006f" -> "hello"
  - Base64:                atob("aGVsbG8=") -> "hello"
  - charCodeAt/fromCharCode: String.fromCharCode(104,101,108,108,111)
  - Array-based lookup:    var _0x1234 = ["hello","world"]; _0x1234[0]

Eval Chains:
  - eval(atob("..."))
  - eval(unescape("..."))
  - new Function("return " + decoded)()
  - document.write("<script>" + decoded + "</script>")
  - setTimeout(decoded, 0)

Control Flow:
  - Switch-case dispatcher with shuffled case order
  - Opaque predicates (always-true/false conditions)
  - Dead code insertion
  - Variable name mangling (_0x4a3b, _0xab12)

Anti-Analysis:
  - Debugger traps: setInterval(function(){debugger;}, 100)
  - Console detection: overriding console.log
  - Timing checks: performance.now() deltas
  - DevTools detection: window.outerWidth - window.innerWidth > 100

Passo 3: Remover Proteções Anti-Análise

Neutralize armadilhas anti-depuração e anti-análise:

// Remove debugger traps before analysis
// Replace in the obfuscated script:

// Before:
setInterval(function() { debugger; }, 100);

// After (neutralized):
setInterval(function() { /* debugger removed */ }, 100);

// Neutralize DevTools detection
// Before:
if (window.outerWidth - window.innerWidth > 160) { window.location = "about:blank"; }

// After:
if (false) { window.location = "about:blank"; }

// Neutralize timing checks
// Override performance.now to return consistent values
const originalNow = performance.now;
performance.now = function() { return 0; };

Passo 4: Decodificar Camadas de Ofuscação de Strings

Decodifique progressivamente strings codificadas:

# Script Python para decodificar padrões comuns de ofuscação de JS
import re
import base64
import urllib.parse

def decode_hex_strings(code):
    """Substitui sequências \\xNN por caracteres ASCII"""
    def hex_replace(match):
        hex_str = match.group(0)
        try:

…