xtofuub/openrecon-ios / skills/_upstream/anthropic-cybersecurity-skills/skills/deobfuscating-javascript-malware
deobfuscating-javascript-malware
UnverifiedDeobfuscates malicious JavaScript code used in web-based attacks, phishing pages, and dropper scripts by reversing encoding layers, eval chains, string manipulation, and control flow obfuscation to reveal the original malicious logic. Activates for requests involving JavaScript malware analysis, script deobfuscation, web skimmer analysis, or obfuscated dropper investigation.
| File | Kind | Size |
|---|---|---|
| LICENSE | other | 11.0 KB |
| SKILL.md | skill md | 12.7 KB |
| references/api-reference.md | markdown | 2.0 KB |
| scripts/agent.py | script | 7.1 KB |
scripts/agent.py
View on GitHub#!/usr/bin/env python3
"""JavaScript malware deobfuscation agent using jsbeautifier and pattern matching."""
import re
import sys
import json
import base64
import urllib.parse
from pathlib import Path
try:
import jsbeautifier
except ImportError:
jsbeautifier = None
def beautify_js(code):
"""Beautify JavaScript code using jsbeautifier."""
if jsbeautifier is None:
return code
opts = jsbeautifier.default_options()
opts.indent_size = 2
opts.wrap_line_length = 120
return jsbeautifier.beautify(code, opts)
def decode_hex_strings(code):
"""Replace \\xNN hex escape sequences with ASCII characters."""
def hex_replace(match):
hex_str = match.group(0)
try:
return bytes.fromhex(hex_str.replace("\\x", "")).decode("ascii", errors="replace")
except Exception:
return hex_str
return re.sub(r'(?:\\x[0-9a-fA-F]{2})+', hex_replace, code)
def decode_unicode_escapes(code):
"""Replace \\uNNNN sequences with actual characters."""
def unicode_replace(match):
try:
return chr(int(match.group(1), 16))
except Exception:
return match.group(0)
return re.sub(r'\\u([0-9a-fA-F]{4})', unicode_replace, code)
def decode_charcode_calls(code):
"""Resolve String.fromCharCode() calls with static arguments."""
def charcode_replace(match):
try:
codes = [int(c.strip()) for c in match.group(1).split(",") if c.strip()]
return '"' + "".join(chr(c) for c in codes) + '"'
except Exception:
return match.group(0)
return re.sub(r'String\.fromCharCode\(([0-9,\s]+)\)', charcode_replace, code)
def decode_atob_calls(code):
"""Resolve atob() calls containing static base64 strings."""
def atob_replace(match):
try:
decoded = base64.b64decode(match.group(1)).decode("utf-8", errors="replace")
return json.dumps(decoded)
except Exception:
return match.group(0)
return re.sub(r'atob\(["\']([A-Za-z0-9+/=]+)["\']\)', atob_replace, code)
def decode_unescape_calls(code):
"""Resolve unescape() calls with percent-encoded strings."""
def unescape_replace(match):
try:
decoded = urllib.parse.unquote(match.group(1))
return json.dumps(decoded)
except Exception:
return match.group(0)
return re.sub(r'unescape\(["\']([^"\']+)["\']\)', unescape_replace, code)
def detect_obfuscation_techniques(code):
"""Identify obfuscation techniques used in the script."""
techniques = []
if re.search(r'\\x[0-9a-fA-F]{2}', code):
techniques.append("hex_encoding")
if re.search(r'\\u[0-9a-fA-F]{4}', code):
techniques.append("unicode_escapes")
if "String.fromCharCode" in code:
techniques.append("fromCharCode")
if "atob(" in code:
techniques.append("base64_atob")
if re.search(r'eval\s*\(', code):
techniques.append("eval_chain")
if "new Function(" in code or "new Function (" in code:
techniques.append("function_constructor")
if re.search(r'document\.write\s*\(', code):
techniques.append("document_write")
if re.search(r'setTimeout\s*\(', code):
techniques.append("setTimeout_exec")
if re.search(r'setInterval\s*\(\s*function\s*\(\)\s*\{\s*debugger', code):
techniques.append("anti_debugging_debugger")
if re.search(r'window\.outerWidth\s*-\s*window\.innerWidth', code):
techniques.append("anti_debugging_devtools")
if re.search(r'performance\.now\s*\(\)', code):
techniques.append("anti_debugging_timing")
if re.search(r'_0x[0-9a-fA-F]+', code):
techniques.append("variable_mangling")
if re.search(r'var\s+_0x[0-9a-fA-F]+\s*=\s*\[', code):
techniques.append("string_array")
if "unescape(" in code:
techniques.append("unescape_encoding")
return techniques
def extract_iocs(code):
"""Extract potential IOCs from deobfuscated JavaScript."""
iocs = {"urls": [], "domains": [], "ips": [], "emails": []}
url_pattern = re.compile(r'https?://[^\s"\'<>\)]+', re.IGNORECASE)
domain_pattern = re.compile(r'(?:[a-zA-Z0-9-]+\.)+(?:com|net|org|io|xyz|top|info|cc|ru|cn|tk)\b')
ip_pattern = re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b')
email_pattern = re.compile(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}')
iocs["urls"] = list(set(url_pattern.findall(code)))
iocs["domains"] = list(set(domain_pattern.findall(code)))
iocs["ips"] = list(set(ip_pattern.findall(code)))
iocs["emails"] = list(set(email_pattern.findall(code)))
return iocs
def remove_anti_debug(code):
"""Remove common anti-debugging traps from JavaScript."""
code = re.sub(
r'setInterval\s*\(\s*function\s*\(\)\s*\{\s*debugger\s*;?\s*\}\s*,\s*\d+\s*\)',
'/* anti-debug removed */',
code
)
code = re.sub(
r'if\s*\(\s*window\.outerWidth\s*-\s*window\.innerWidth\s*>\s*\d+\s*\)[^}]*\}',
'/* devtools detection removed */',
code
)
return code
def deobfuscate(code, remove_debug=True):
"""Apply all deobfuscation passes to JavaScript code."""
if remove_debug:
code = remove_anti_debug(code)
code = decode_hex_strings(code)
code = decode_unicode_escapes(code)
code = decode_charcode_calls(code)
code = decode_atob_calls(code)
code = decode_unescape_calls(code)
code = beautify_js(code)
return code
def extract_scripts_from_html(html_content):
"""Extract inline JavaScript from HTML file."""
pattern = re.compile(r'<script[^>]*>(.*?)</script>', re.DOTALL | re.IGNORECASE)
scripts = pattern.findall(html_content)
return [s.strip() for s in scripts if s.strip()]
def analyze_file(file_path):
"""Full analysis pipeline for a JavaScript or HTML file."""
path = Path(file_path)
if not path.exists():
return {"error": f"File not found: {file_path}"}
content = path.read_text(encoding="utf-8", errors="replace")
if path.suffix.lower() in (".html", ".htm"):
scripts = extract_scripts_from_html(content)
else:
scripts = [content]
results = []
for i, script in enumerate(scripts):
techniques = detect_obfuscation_techniques(script)
deobfuscated = deobfuscate(script)
iocs = extract_iocs(deobfuscated)
results.append({
"script_index": i,
"original_size": len(script),
"deobfuscated_size": len(deobfuscated),
"obfuscation_techniques": techniques,
"iocs": iocs,
"deobfuscated_preview": deobfuscated[:2000],
})
return {
"file": file_path,
"script_count": len(scripts),
"analyses": results,
}
if __name__ == "__main__":
if len(sys.argv) < 2:
print("Usage: agent.py <file.js|file.html> [--full]")
sys.exit(1)
result = analyze_file(sys.argv[1])
if "--full" in sys.argv:
print(json.dumps(result, indent=2, default=str))
else:
for analysis in result.get("analyses", []):
analysis.pop("deobfuscated_preview", None)
print(json.dumps(result, indent=2, default=str))
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 318k | Updated | Claude CodeCodex | Unverified | Install |