Reverse Engineering Rust Malware
Overview
Rust has become increasingly popular for malware development due to its cross-compilation, memory safety guarantees, and the complexity it introduces for reverse engineers. Rust binaries contain the entire standard library statically linked, producing large binaries with extensive boilerplate code. Key challenges include non-null-terminated strings (Rust uses fat pointers with pointer+length), monomorphization generating duplicated generic code, complex error handling (Result/Option unwrap chains), and unfamiliar calling conventions. Decompiling Rust to C produces unhelpful output compared to C/C++ binaries. Tools like Ghidra scripts for crate extraction, and training focused on Rust-specific patterns (2024-2025) help address these challenges. Notable Rust malware includes BlackCat/ALPHV ransomware, Hive ransomware variants, and Buer Loader.
When to Use
- When performing authorized security testing that involves reverse engineering rust malware
- When analyzing malware samples or attack artifacts in a controlled environment
- When conducting red team exercises or penetration testing engagements
- When building detection capabilities based on offensive technique understanding
Prerequisites
- IDA Pro 8.0+ or Ghidra 11.0+
- Rust toolchain for reference compilation
- Python 3.9+ for helper scripts
- Understanding of Rust memory model (ownership, borrowing)
- Familiarity with Rust string types (String, &str, CString)
Workflow
Step 1: Identify and Parse Rust Binary Metadata
#!/usr/bin/env python3
"""Analyze Rust malware binary metadata and extract crate dependencies."""
import re
import sys
import json
def identify_rust_binary(data):
"""Check if binary is Rust-compiled and extract version info."""
indicators = {
"rust_panic_strings": bool(re.search(rb'panicked at', data)),
"rust_unwrap": bool(re.search(rb'called.*unwrap.*on.*None', data)),
"core_panic": bool(re.search(rb'core::panicking', data)),
"std_rt": bool(re.search(rb'std::rt::lang_start', data)),
"cargo_path": bool(re.search(rb'\.cargo[/\\]registry', data)),
"rustc_version": None,
}
version = re.search(rb'rustc\s+(\d+\.\d+\.\d+)', data)
if version:
indicators["rustc_version"] = version.group(1).decode()
is_rust = sum(1 for v in indicators.values() if v) >= 2
return is_rust, indicators
def extract_crates(data):
"""Extract Rust crate (dependency) names from binary strings."""
crate_pattern = re.compile(
rb'(?:crates\.io-[a-f0-9]+/|\.cargo/registry/src/[^/]+/)'
rb'([\w-]+)-(\d+\.\d+\.\d+)'
)
crates = {}
for match in crate_pattern.finditer(data):
name = match.group(1).decode()
version = match.group(2).decode()
crates[name] = version
# Also check for common malware-relevant crates
suspicious_crates = {
"reqwest": "HTTP client",
"hyper": "HTTP library",
"tokio": "Async runtime",
"aes": "AES encryption",
"chacha20": "ChaCha20 encryption",
"rsa": "RSA encryption",
"ring": "Crypto library",
"base64": "Base64 encoding",
"winapi": "Windows API bindings",
"winreg": "Registry access",
"sysinfo": "System information",
"screenshots": "Screen capture",
"clipboard": "Clipboard access",
"keylogger": "Key logging",
}
capabilities = []
for crate_name, description in suspicious_crates.items():
if crate_name in crates:
capabilities.append({
"crate": crate_name,
"version": crates[crate_name],
"capability": description,
})
return crates, capabilities
def extract_rust_strings(data):
"""Extract strings handling Rust's non-null-terminated format."""
# Rust strings are stored as pointer+length, but string literals
# are often in .rodata as contiguous sequences
strings = []
ascii_pattern = re.compile(rb'[\x20-\x7e]{8,500}')
for match in ascii_pattern.finditer(data):
s = match.group().decode('ascii')
# Filter for malware-relevant strings
keywords = ['http', 'socket', 'encrypt', 'decrypt', 'shell',
'exec', 'cmd', 'upload', 'download', 'persist',
'registry', 'mutex', 'pipe', 'inject']
if any(kw in s.lower() for kw in keywords):
strings.append(s)
return strings
if __name__ == "__main__":
if len(sys.argv) < 2:
print(f"Usage: {sys.argv[0]} <rust_binary>")
sys.exit(1)
with open(sys.argv[1], 'rb') as f:
data = f.read()
is_rust, indicators = identify_rust_binary(data)
print(f"[{'+'if is_rust else '-'}] Rust binary: {is_rust}")
print(json.dumps(indicators, indent=2, default=str))
crates, capabilities = extract_crates(data)
print(f"\n[+] Crates ({len(crates)}):")
for name, ver in sorted(crates.items()):
print(f" {name} v{ver}")
if capabilities:
print(f"\n[!] Suspicious capabilities:")
for cap in capabilities:
print(f" {cap['crate']} -> {cap['capability']}")
strings = extract_rust_strings(data)
if strings:
print(f"\n[+] Suspicious strings ({len(strings)}):")
for s in strings[:20]:
print(f" {s}")
Validation Criteria
- Binary correctly identified as Rust-compiled with version info
- Crate dependencies extracted revealing malware capabilities
- Rust-specific string extraction handles fat pointer format
- Main entry point and core logic functions identified
- Encryption, networking, and persistence code located
References
1---2name: reverse-engineering-rust-malware3description: Reverse engineers Rust-compiled malware using IDA Pro and Ghidra, covering4 techniques for non-null-terminated fat-pointer strings, monomorphized/duplicated5 generic code, Result/Option unwrap chains, crate dependency extraction, and Rust-specific6 control flow and calling conventions. Use when analyzing Rust-based malware samples7 (e.g. BlackCat/ALPHV, Hive, Buer Loader) or attack artifacts in an authorized, controlled8 environment.9domain: cybersecurity10subdomain: malware-analysis11tags:12- rust13- reverse-engineering14- malware-analysis15- ghidra16- ida-pro17- binary-analysis18- rust-malware19version: '1.0'20author: mahipal21license: Apache-2.022nist_csf:23- DE.AE-0224- RS.AN-0325- ID.RA-0126- DE.CM-0127mitre_attack:28- T102729- T105530- T114031- T149732metadata:33 source: https://skillmd.com/skills/26zl/reverse-engineering-rust-malware34---3536# Reverse Engineering Rust Malware3738## Overview3940Rust has become increasingly popular for malware development due to its cross-compilation, memory safety guarantees, and the complexity it introduces for reverse engineers. Rust binaries contain the entire standard library statically linked, producing large binaries with extensive boilerplate code. Key challenges include non-null-terminated strings (Rust uses fat pointers with pointer+length), monomorphization generating duplicated generic code, complex error handling (Result/Option unwrap chains), and unfamiliar calling conventions. Decompiling Rust to C produces unhelpful output compared to C/C++ binaries. Tools like Ghidra scripts for crate extraction, and training focused on Rust-specific patterns (2024-2025) help address these challenges. Notable Rust malware includes BlackCat/ALPHV ransomware, Hive ransomware variants, and Buer Loader.414243## When to Use4445- When performing authorized security testing that involves reverse engineering rust malware46- When analyzing malware samples or attack artifacts in a controlled environment47- When conducting red team exercises or penetration testing engagements48- When building detection capabilities based on offensive technique understanding4950## Prerequisites5152- IDA Pro 8.0+ or Ghidra 11.0+53- Rust toolchain for reference compilation54- Python 3.9+ for helper scripts55- Understanding of Rust memory model (ownership, borrowing)56- Familiarity with Rust string types (String, &str, CString)5758## Workflow5960### Step 1: Identify and Parse Rust Binary Metadata6162```python63#!/usr/bin/env python364"""Analyze Rust malware binary metadata and extract crate dependencies."""65import re66import sys67import json686970def identify_rust_binary(data):71 """Check if binary is Rust-compiled and extract version info."""72 indicators = {73 "rust_panic_strings": bool(re.search(rb'panicked at', data)),74 "rust_unwrap": bool(re.search(rb'called.*unwrap.*on.*None', data)),75 "core_panic": bool(re.search(rb'core::panicking', data)),76 "std_rt": bool(re.search(rb'std::rt::lang_start', data)),77 "cargo_path": bool(re.search(rb'\.cargo[/\\]registry', data)),78 "rustc_version": None,79 }8081 version = re.search(rb'rustc\s+(\d+\.\d+\.\d+)', data)82 if version:83 indicators["rustc_version"] = version.group(1).decode()8485 is_rust = sum(1 for v in indicators.values() if v) >= 286 return is_rust, indicators878889def extract_crates(data):90 """Extract Rust crate (dependency) names from binary strings."""91 crate_pattern = re.compile(92 rb'(?:crates\.io-[a-f0-9]+/|\.cargo/registry/src/[^/]+/)'93 rb'([\w-]+)-(\d+\.\d+\.\d+)'94 )95 crates = {}96 for match in crate_pattern.finditer(data):97 name = match.group(1).decode()98 version = match.group(2).decode()99 crates[name] = version100101 # Also check for common malware-relevant crates102 suspicious_crates = {103 "reqwest": "HTTP client",104 "hyper": "HTTP library",105 "tokio": "Async runtime",106 "aes": "AES encryption",107 "chacha20": "ChaCha20 encryption",108 "rsa": "RSA encryption",109 "ring": "Crypto library",110 "base64": "Base64 encoding",111 "winapi": "Windows API bindings",112 "winreg": "Registry access",113 "sysinfo": "System information",114 "screenshots": "Screen capture",115 "clipboard": "Clipboard access",116 "keylogger": "Key logging",117 }118119 capabilities = []120 for crate_name, description in suspicious_crates.items():121 if crate_name in crates:122 capabilities.append({123 "crate": crate_name,124 "version": crates[crate_name],125 "capability": description,126 })127128 return crates, capabilities129130131def extract_rust_strings(data):132 """Extract strings handling Rust's non-null-terminated format."""133 # Rust strings are stored as pointer+length, but string literals134 # are often in .rodata as contiguous sequences135 strings = []136 ascii_pattern = re.compile(rb'[\x20-\x7e]{8,500}')137 for match in ascii_pattern.finditer(data):138 s = match.group().decode('ascii')139 # Filter for malware-relevant strings140 keywords = ['http', 'socket', 'encrypt', 'decrypt', 'shell',141 'exec', 'cmd', 'upload', 'download', 'persist',142 'registry', 'mutex', 'pipe', 'inject']143 if any(kw in s.lower() for kw in keywords):144 strings.append(s)145146 return strings147148149if __name__ == "__main__":150 if len(sys.argv) < 2:151 print(f"Usage: {sys.argv[0]} <rust_binary>")152 sys.exit(1)153154 with open(sys.argv[1], 'rb') as f:155 data = f.read()156157 is_rust, indicators = identify_rust_binary(data)158 print(f"[{'+'if is_rust else '-'}] Rust binary: {is_rust}")159 print(json.dumps(indicators, indent=2, default=str))160161 crates, capabilities = extract_crates(data)162 print(f"\n[+] Crates ({len(crates)}):")163 for name, ver in sorted(crates.items()):164 print(f" {name} v{ver}")165166 if capabilities:167 print(f"\n[!] Suspicious capabilities:")168 for cap in capabilities:169 print(f" {cap['crate']} -> {cap['capability']}")170171 strings = extract_rust_strings(data)172 if strings:173 print(f"\n[+] Suspicious strings ({len(strings)}):")174 for s in strings[:20]:175 print(f" {s}")176```177178## Validation Criteria179180- Binary correctly identified as Rust-compiled with version info181- Crate dependencies extracted revealing malware capabilities182- Rust-specific string extraction handles fat pointer format183- Main entry point and core logic functions identified184- Encryption, networking, and persistence code located185186## References187188- [Binary Defense - Extracting Secrets from Rust Malware](https://binarydefense.com/resources/blog/digging-through-rust-to-find-gold-extracting-secrets-from-rust-malware)189- [Ghidra Extension for Rust Analysis](https://cir.nii.ac.jp/crid/1050302237609671296)190- [Fuzzing Labs - Reversing Modern Binaries](https://fuzzinglabs.com/reversing-modern-binaries/)191- [Bishop Fox - Rust for Malware Development](https://bishopfox.com/blog/rust-for-malware-development)