Analyzing Linux ELF Malware
When to Use
- A Linux server or container has been compromised and suspicious ELF binaries are found
- Analyzing Linux botnets (Mirai, Gafgyt, XorDDoS), cryptominers, or ransomware
- Investigating malware targeting cloud infrastructure, Docker containers, or Kubernetes pods
- Reverse engineering Linux rootkits and kernel modules
- Analyzing cross-platform malware compiled for Linux x86_64, ARM, or MIPS architectures
Do not use for Windows PE binary analysis; use PEStudio, Ghidra, or IDA for Windows malware.
Detection Gaps & Validation
- Modified packers break
upx -d. IoT/Linux malware ships UPX with corrupted magic or custom packers; upx -t/-d fails and strings returns garbage. Unpack manually (dump from memory after the stub runs, or repair the UPX header) and re-run static analysis before concluding there are no IOCs.
- Stripped + statically linked hides everything. No
.symtab, no ldd imports - capability lives in raw syscalls. Use readelf -r/objdump -d and trace socket/connect/execve/ptrace rather than relying on imported symbol names.
- Anti-analysis aborts behavior. Samples check
ptrace(PTRACE_TRACEME), /proc/self/status (TracerPid), uptime, CPU count, and container hints; under strace/gdb they exit clean, mimicking a benign binary.
- Architecture mismatch. Running an ARM/MIPS sample on x86_64 yields nothing (and
ldd/execution can run attacker code). Confirm arch with readelf -h and detonate under matching qemu-user.
- Confirm a hit: correlate static strings with dynamic strace/ltrace output and live network captures, prove C2 endpoints are reachable/hostile, and check for companion
.sh droppers that handle persistence and cleanup.
- False positives: BusyBox, statically linked Go/Rust CLIs, and legitimate XMRig on mining hosts look malware-like (packed, static, network+crypto). Confirm intent from persistence and C2, not from packing or static linking alone.
Prerequisites
- Ghidra or IDA with Linux ELF support for disassembly and decompilation
- Linux analysis VM (Ubuntu 22.04 recommended) with development tools installed
- strace, ltrace, and GDB for dynamic analysis and debugging
- readelf, objdump, and nm from GNU binutils for static inspection
- Radare2 for quick binary triage and scripted analysis
- Docker for isolated container-based malware execution
Workflow
Step 1: Identify ELF Binary Properties
Examine the ELF header and basic properties:
# File type identification
file suspect_binary
# Detailed ELF header analysis
readelf -h suspect_binary
# Section headers
readelf -S suspect_binary
# Program headers (segments)
readelf -l suspect_binary
# Symbol table (if not stripped)
readelf -s suspect_binary
nm suspect_binary 2>/dev/null
# Dynamic linking information
readelf -d suspect_binary
ldd suspect_binary 2>/dev/null # Only on matching architecture!
# Compute hashes
md5sum suspect_binary
sha256sum suspect_binary
# Check for packing/UPX
upx -t suspect_binary
# Python-based ELF analysis
from elftools.elf.elffile import ELFFile
import hashlib
with open("suspect_binary", "rb") as f:
data = f.read()
sha256 = hashlib.sha256(data).hexdigest()
with open("suspect_binary", "rb") as f:
elf = ELFFile(f)
print(f"SHA-256: {sha256}")
print(f"Class: {elf.elfclass}-bit")
print(f"Endian: {elf.little_endian and 'Little' or 'Big'}")
print(f"Machine: {elf.header.e_machine}")
print(f"Type: {elf.header.e_type}")
print(f"Entry Point: 0x{elf.header.e_entry:X}")
# Check if stripped
symtab = elf.get_section_by_name('.symtab')
print(f"Stripped: {'Yes' if symtab is None else 'No'}")
# Section entropy analysis
import math
from collections import Counter
for section in elf.iter_sections():
data = section.data()
if len(data) > 0:
entropy = -sum((c/len(data)) * math.log2(c/len(data))
for c in Counter(data).values() if c > 0)
if entropy > 7.0:
print(f" [!] High entropy section: {section.name} ({entropy:.2f})")
Step 2: Extract Strings and Indicators
Search for embedded IOCs and functionality clues:
# ASCII strings
strings suspect_binary > strings_output.txt
# Search for network indicators
grep -iE "(http|https|ftp)://" strings_output.txt
grep -iE "([0-9]{1,3}\.){3}[0-9]{1,3}" strings_output.txt
grep -iE "[a-zA-Z0-9.-]+\.(com|net|org|io|ru|cn)" strings_output.txt
# Search for shell commands
grep -iE "(bash|sh|wget|curl|chmod|/tmp/|/dev/)" strings_output.txt
# Search for crypto mining indicators
grep -iE "(stratum|xmr|monero|pool\.|mining)" strings_output.txt
# Search for SSH/credential theft
grep -iE "(ssh|authorized_keys|id_rsa|shadow|passwd)" strings_output.txt
# Search for persistence mechanisms
grep -iE "(crontab|systemd|init\.d|rc\.local|ld\.so\.preload)" strings_output.txt
# FLOSS for obfuscated strings (if available)
floss suspect_binary
Step 3: Analyze System Calls and Library Usage
Identify what system calls and libraries the malware uses:
# List imported functions (dynamically linked)
readelf -r suspect_binary | grep -E "socket|connect|exec|fork|open|write|bind|listen"
# Trace system calls during execution (in isolated VM only)
strace -f -e trace=network,process,file -o strace_output.txt ./suspect_binary
# Trace library calls
ltrace -f -o ltrace_output.txt ./suspect_binary
# Key system calls to watch:
# Network: socket, connect, bind, listen, accept, sendto, recvfrom
# Process: fork, execve, clone, kill, ptrace
# File: open, read, write, unlink, rename, chmod
# Persistence: inotify_add_watch (file monitoring)
Step 4: Dynamic Analysis with GDB
Debug the malware to observe runtime behavior:
# Start GDB with the binary
gdb ./suspect_binary
# Set breakpoints on key functions
(gdb) break main
(gdb) break socket
(gdb) break connect
(gdb) break execve
(gdb) break fork
# Run and analyze
(gdb) run
(gdb) info registers # View register state
(gdb) x/20s $rdi # Examine string argument
(gdb) bt # Backtrace
(gdb) continue
# For stripped binaries, break on entry point
(gdb) break *0x400580 # Entry point from readelf
(gdb) run
# Monitor network connections during execution
# In another terminal:
ss -tlnp # List listening sockets
ss -tnp # List established connections
Step 5: Reverse Engineer with Ghidra
Perform deep code analysis on the ELF binary:
Ghidra Analysis for Linux ELF:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. Import: File -> Import -> Select ELF binary
- Ghidra auto-detects ELF format and architecture
- Accept default analysis options
2. Key analysis targets:
- main() function (or entry point if stripped)
- Socket creation and connection functions
- Command dispatch logic (switch/case on received data)
- Encryption/encoding routines
- Persistence installation code
- Self-propagation/scanning functions
3. For Mirai-like botnets, look for:
- Credential list for brute-forcing (telnet/SSH)
- Attack module selection (UDP flood, SYN flood, ACK flood)
- Scanner module (port scanning for vulnerable devices)
- Killer module (killing competing botnets)
4. For cryptominers, look for:
- Mining pool connection (stratum protocol)
- Wallet address strings
- CPU/GPU utilization functions
- Process hiding techniques
Step 6: Analyze Linux-Specific Persistence
Check for persistence mechanisms:
# Check for LD_PRELOAD rootkit
strings suspect_binary | grep "ld.so.preload"
# Malware writing to /etc/ld.so.preload can hook all dynamic library calls
# Check for crontab persistence
strings suspect_binary | grep -i "cron"
# Check for systemd service creation
strings suspect_binary | grep -iE "systemd|\.service|systemctl"
# Check for init script creation
strings suspect_binary | grep -iE "init\.d|rc\.local|update-rc"
# Check for SSH key injection
strings suspect_binary | grep -i "authorized_keys"
# Check for kernel module (rootkit) loading
strings suspect_binary | grep -iE "insmod|modprobe|init_module"
# Check for process hiding
strings suspect_binary | grep -iE "proc|readdir|getdents"
Key Concepts
| Term |
Definition |
| ELF (Executable and Linkable Format) |
Standard binary format for Linux executables, shared libraries, and core dumps containing headers, sections, and segments |
| Stripped Binary |
ELF binary with debug symbols removed, making reverse engineering more difficult as function names are lost |
| LD_PRELOAD |
Linux environment variable specifying shared libraries to load before all others; abused by rootkits to intercept system library calls |
| strace |
Linux system call tracer that logs all system calls and signals made by a process, revealing file, network, and process operations |
| GOT/PLT |
Global Offset Table and Procedure Linkage Table; ELF structures for dynamic linking that can be hijacked for function hooking |
| Statically Linked |
Binary compiled with all library code included; common in IoT malware to run on systems without matching shared libraries |
| Mirai |
Prolific Linux botnet targeting IoT devices via telnet brute-force; source code leaked, leading to many variants |
Tools & Systems
- Ghidra: NSA reverse engineering tool with full ELF support for x86, x86_64, ARM, MIPS, and other Linux architectures
- Radare2: Open-source reverse engineering framework with command-line interface for quick binary analysis and scripting
- strace: Linux system call tracing tool for observing binary behavior including file, network, and process operations
- GDB: GNU Debugger for setting breakpoints, examining memory, and stepping through Linux binary execution
- pyelftools: Python library for parsing ELF files programmatically for automated analysis pipelines
Common Scenarios
Scenario: Analyzing a Cryptominer Found on a Compromised Linux Server
Context: A cloud server shows 100% CPU usage. Investigation reveals an unknown binary running from /tmp with a suspicious name. The binary needs analysis to confirm it is a cryptominer and identify the attacker's wallet and pool.
Approach:
- Copy the binary to an analysis VM and compute SHA-256 hash
- Run
file and readelf to identify architecture and linking type
- Extract strings and search for mining pool addresses (stratum+tcp://) and wallet addresses
- Run with strace in a sandbox to observe network connections (mining pool connection)
- Import into Ghidra to identify the mining algorithm and configuration extraction
- Check for persistence mechanisms (crontab, systemd service, SSH keys)
- Document all IOCs including pool address, wallet, C2 for updates, and persistence artifacts
Pitfalls:
- Running
ldd on malware outside a sandbox (ldd can execute code in the binary)
- Not checking for ARM/MIPS architecture before attempting x86_64 execution
- Missing companion scripts (.sh files) that may handle persistence and cleanup
- Ignoring the initial access vector (how the miner was deployed: SSH brute force, web exploit, container escape)
Output Format
LINUX ELF MALWARE ANALYSIS REPORT
====================================
File: /tmp/.X11-unix/.rsync
SHA-256: e3b0c44298fc1c149afbf4c8996fb924...
Type: ELF 64-bit LSB executable, x86-64
Linking: Statically linked (all libraries embedded)
Stripped: Yes
Size: 2,847,232 bytes
Packer: UPX 3.96 (unpacked for analysis)
CLASSIFICATION
Family: XMRig Cryptominer (modified)
Variant: Custom build with C2 update mechanism
FUNCTIONALITY
[*] XMR (Monero) mining via RandomX algorithm
[*] Stratum pool connection for work submission
[*] C2 check-in for configuration updates
[*] Process name masquerading (argv[0] = "[kworker/0:0]")
[*] Competitor process killing (kills other miners)
[*] SSH key injection for re-access
NETWORK INDICATORS
Mining Pool: stratum+tcp://pool.minexmr[.]com:4444
C2 Server: hxxp://update.malicious[.]com/config
Wallet: 49jZ5Q3b...Monero_Wallet_Address...
PERSISTENCE
[1] Crontab entry: */5 * * * * /tmp/.X11-unix/.rsync
[2] SSH key added to /root/.ssh/authorized_keys
[3] Systemd service: /etc/systemd/system/rsync-daemon.service
[4] Modified /etc/ld.so.preload for process hiding
PROCESS HIDING
LD_PRELOAD: /usr/lib/.libsystem.so
Hook: readdir() to hide /tmp/.X11-unix/.rsync from ls
Hook: fopen() to hide from /proc/*/maps reading
1---2name: analyzing-linux-elf-malware3description: 'Analyzes malicious Linux ELF (Executable and Linkable Format) binaries including botnets, cryptominers, ransomware,4 and rootkits targeting Linux servers, containers, and cloud infrastructure. Covers static analysis, dynamic tracing, and5 reverse engineering of x86_64 and ARM ELF samples. Activates for requests involving Linux malware analysis, ELF binary investigation,6 Linux server compromise assessment, or container malware analysis.78 '9domain: cybersecurity10subdomain: malware-analysis11tags:12- malware13- Linux14- ELF15- reverse-engineering16- server-malware17version: 1.0.018author: Krishna Kumar (xalgord)19license: Apache-2.020nist_csf:21- DE.AE-0222- RS.AN-0323- ID.RA-0124- DE.CM-0125metadata:26 source: https://skillmd.com/skills/xalgord/analyzing-linux-elf-malware27---2829# Analyzing Linux ELF Malware3031## When to Use3233- A Linux server or container has been compromised and suspicious ELF binaries are found34- Analyzing Linux botnets (Mirai, Gafgyt, XorDDoS), cryptominers, or ransomware35- Investigating malware targeting cloud infrastructure, Docker containers, or Kubernetes pods36- Reverse engineering Linux rootkits and kernel modules37- Analyzing cross-platform malware compiled for Linux x86_64, ARM, or MIPS architectures3839**Do not use** for Windows PE binary analysis; use PEStudio, Ghidra, or IDA for Windows malware.4041## Detection Gaps & Validation4243- **Modified packers break `upx -d`.** IoT/Linux malware ships UPX with corrupted magic or custom packers; `upx -t`/`-d` fails and `strings` returns garbage. Unpack manually (dump from memory after the stub runs, or repair the UPX header) and re-run static analysis before concluding there are no IOCs.44- **Stripped + statically linked hides everything.** No `.symtab`, no `ldd` imports - capability lives in raw syscalls. Use `readelf -r`/`objdump -d` and trace `socket`/`connect`/`execve`/`ptrace` rather than relying on imported symbol names.45- **Anti-analysis aborts behavior.** Samples check `ptrace(PTRACE_TRACEME)`, `/proc/self/status` (TracerPid), uptime, CPU count, and container hints; under strace/gdb they exit clean, mimicking a benign binary.46- **Architecture mismatch.** Running an ARM/MIPS sample on x86_64 yields nothing (and `ldd`/execution can run attacker code). Confirm arch with `readelf -h` and detonate under matching `qemu-user`.47- **Confirm a hit:** correlate static strings with dynamic strace/ltrace output and live network captures, prove C2 endpoints are reachable/hostile, and check for companion `.sh` droppers that handle persistence and cleanup.48- **False positives:** BusyBox, statically linked Go/Rust CLIs, and legitimate XMRig on mining hosts look malware-like (packed, static, network+crypto). Confirm intent from persistence and C2, not from packing or static linking alone.4950## Prerequisites5152- Ghidra or IDA with Linux ELF support for disassembly and decompilation53- Linux analysis VM (Ubuntu 22.04 recommended) with development tools installed54- strace, ltrace, and GDB for dynamic analysis and debugging55- readelf, objdump, and nm from GNU binutils for static inspection56- Radare2 for quick binary triage and scripted analysis57- Docker for isolated container-based malware execution5859## Workflow6061### Step 1: Identify ELF Binary Properties6263Examine the ELF header and basic properties:6465```bash66# File type identification67file suspect_binary6869# Detailed ELF header analysis70readelf -h suspect_binary7172# Section headers73readelf -S suspect_binary7475# Program headers (segments)76readelf -l suspect_binary7778# Symbol table (if not stripped)79readelf -s suspect_binary80nm suspect_binary 2>/dev/null8182# Dynamic linking information83readelf -d suspect_binary84ldd suspect_binary 2>/dev/null # Only on matching architecture!8586# Compute hashes87md5sum suspect_binary88sha256sum suspect_binary8990# Check for packing/UPX91upx -t suspect_binary92```9394```python95# Python-based ELF analysis96from elftools.elf.elffile import ELFFile97import hashlib9899with open("suspect_binary", "rb") as f:100 data = f.read()101 sha256 = hashlib.sha256(data).hexdigest()102103with open("suspect_binary", "rb") as f:104 elf = ELFFile(f)105106 print(f"SHA-256: {sha256}")107 print(f"Class: {elf.elfclass}-bit")108 print(f"Endian: {elf.little_endian and 'Little' or 'Big'}")109 print(f"Machine: {elf.header.e_machine}")110 print(f"Type: {elf.header.e_type}")111 print(f"Entry Point: 0x{elf.header.e_entry:X}")112113 # Check if stripped114 symtab = elf.get_section_by_name('.symtab')115 print(f"Stripped: {'Yes' if symtab is None else 'No'}")116117 # Section entropy analysis118 import math119 from collections import Counter120 for section in elf.iter_sections():121 data = section.data()122 if len(data) > 0:123 entropy = -sum((c/len(data)) * math.log2(c/len(data))124 for c in Counter(data).values() if c > 0)125 if entropy > 7.0:126 print(f" [!] High entropy section: {section.name} ({entropy:.2f})")127```128129### Step 2: Extract Strings and Indicators130131Search for embedded IOCs and functionality clues:132133```bash134# ASCII strings135strings suspect_binary > strings_output.txt136137# Search for network indicators138grep -iE "(http|https|ftp)://" strings_output.txt139grep -iE "([0-9]{1,3}\.){3}[0-9]{1,3}" strings_output.txt140grep -iE "[a-zA-Z0-9.-]+\.(com|net|org|io|ru|cn)" strings_output.txt141142# Search for shell commands143grep -iE "(bash|sh|wget|curl|chmod|/tmp/|/dev/)" strings_output.txt144145# Search for crypto mining indicators146grep -iE "(stratum|xmr|monero|pool\.|mining)" strings_output.txt147148# Search for SSH/credential theft149grep -iE "(ssh|authorized_keys|id_rsa|shadow|passwd)" strings_output.txt150151# Search for persistence mechanisms152grep -iE "(crontab|systemd|init\.d|rc\.local|ld\.so\.preload)" strings_output.txt153154# FLOSS for obfuscated strings (if available)155floss suspect_binary156```157158### Step 3: Analyze System Calls and Library Usage159160Identify what system calls and libraries the malware uses:161162```bash163# List imported functions (dynamically linked)164readelf -r suspect_binary | grep -E "socket|connect|exec|fork|open|write|bind|listen"165166# Trace system calls during execution (in isolated VM only)167strace -f -e trace=network,process,file -o strace_output.txt ./suspect_binary168169# Trace library calls170ltrace -f -o ltrace_output.txt ./suspect_binary171172# Key system calls to watch:173# Network: socket, connect, bind, listen, accept, sendto, recvfrom174# Process: fork, execve, clone, kill, ptrace175# File: open, read, write, unlink, rename, chmod176# Persistence: inotify_add_watch (file monitoring)177```178179### Step 4: Dynamic Analysis with GDB180181Debug the malware to observe runtime behavior:182183```text184# Start GDB with the binary185gdb ./suspect_binary186187# Set breakpoints on key functions188(gdb) break main189(gdb) break socket190(gdb) break connect191(gdb) break execve192(gdb) break fork193194# Run and analyze195(gdb) run196(gdb) info registers # View register state197(gdb) x/20s $rdi # Examine string argument198(gdb) bt # Backtrace199(gdb) continue200201# For stripped binaries, break on entry point202(gdb) break *0x400580 # Entry point from readelf203(gdb) run204205# Monitor network connections during execution206# In another terminal:207ss -tlnp # List listening sockets208ss -tnp # List established connections209```210211### Step 5: Reverse Engineer with Ghidra212213Perform deep code analysis on the ELF binary:214215```216Ghidra Analysis for Linux ELF:217━━━━━━━━━━━━━━━━━━━━━━━━━━━━━2181. Import: File -> Import -> Select ELF binary219 - Ghidra auto-detects ELF format and architecture220 - Accept default analysis options2212222. Key analysis targets:223 - main() function (or entry point if stripped)224 - Socket creation and connection functions225 - Command dispatch logic (switch/case on received data)226 - Encryption/encoding routines227 - Persistence installation code228 - Self-propagation/scanning functions2292303. For Mirai-like botnets, look for:231 - Credential list for brute-forcing (telnet/SSH)232 - Attack module selection (UDP flood, SYN flood, ACK flood)233 - Scanner module (port scanning for vulnerable devices)234 - Killer module (killing competing botnets)2352364. For cryptominers, look for:237 - Mining pool connection (stratum protocol)238 - Wallet address strings239 - CPU/GPU utilization functions240 - Process hiding techniques241```242243### Step 6: Analyze Linux-Specific Persistence244245Check for persistence mechanisms:246247```bash248# Check for LD_PRELOAD rootkit249strings suspect_binary | grep "ld.so.preload"250# Malware writing to /etc/ld.so.preload can hook all dynamic library calls251252# Check for crontab persistence253strings suspect_binary | grep -i "cron"254255# Check for systemd service creation256strings suspect_binary | grep -iE "systemd|\.service|systemctl"257258# Check for init script creation259strings suspect_binary | grep -iE "init\.d|rc\.local|update-rc"260261# Check for SSH key injection262strings suspect_binary | grep -i "authorized_keys"263264# Check for kernel module (rootkit) loading265strings suspect_binary | grep -iE "insmod|modprobe|init_module"266267# Check for process hiding268strings suspect_binary | grep -iE "proc|readdir|getdents"269```270271## Key Concepts272273| Term | Definition |274|------|------------|275| **ELF (Executable and Linkable Format)** | Standard binary format for Linux executables, shared libraries, and core dumps containing headers, sections, and segments |276| **Stripped Binary** | ELF binary with debug symbols removed, making reverse engineering more difficult as function names are lost |277| **LD_PRELOAD** | Linux environment variable specifying shared libraries to load before all others; abused by rootkits to intercept system library calls |278| **strace** | Linux system call tracer that logs all system calls and signals made by a process, revealing file, network, and process operations |279| **GOT/PLT** | Global Offset Table and Procedure Linkage Table; ELF structures for dynamic linking that can be hijacked for function hooking |280| **Statically Linked** | Binary compiled with all library code included; common in IoT malware to run on systems without matching shared libraries |281| **Mirai** | Prolific Linux botnet targeting IoT devices via telnet brute-force; source code leaked, leading to many variants |282283## Tools & Systems284285- **Ghidra**: NSA reverse engineering tool with full ELF support for x86, x86_64, ARM, MIPS, and other Linux architectures286- **Radare2**: Open-source reverse engineering framework with command-line interface for quick binary analysis and scripting287- **strace**: Linux system call tracing tool for observing binary behavior including file, network, and process operations288- **GDB**: GNU Debugger for setting breakpoints, examining memory, and stepping through Linux binary execution289- **pyelftools**: Python library for parsing ELF files programmatically for automated analysis pipelines290291## Common Scenarios292293### Scenario: Analyzing a Cryptominer Found on a Compromised Linux Server294295**Context**: A cloud server shows 100% CPU usage. Investigation reveals an unknown binary running from /tmp with a suspicious name. The binary needs analysis to confirm it is a cryptominer and identify the attacker's wallet and pool.296297**Approach**:2981. Copy the binary to an analysis VM and compute SHA-256 hash2992. Run `file` and `readelf` to identify architecture and linking type3003. Extract strings and search for mining pool addresses (stratum+tcp://) and wallet addresses3014. Run with strace in a sandbox to observe network connections (mining pool connection)3025. Import into Ghidra to identify the mining algorithm and configuration extraction3036. Check for persistence mechanisms (crontab, systemd service, SSH keys)3047. Document all IOCs including pool address, wallet, C2 for updates, and persistence artifacts305306**Pitfalls**:307- Running `ldd` on malware outside a sandbox (ldd can execute code in the binary)308- Not checking for ARM/MIPS architecture before attempting x86_64 execution309- Missing companion scripts (.sh files) that may handle persistence and cleanup310- Ignoring the initial access vector (how the miner was deployed: SSH brute force, web exploit, container escape)311312## Output Format313314```315LINUX ELF MALWARE ANALYSIS REPORT316====================================317File: /tmp/.X11-unix/.rsync318SHA-256: e3b0c44298fc1c149afbf4c8996fb924...319Type: ELF 64-bit LSB executable, x86-64320Linking: Statically linked (all libraries embedded)321Stripped: Yes322Size: 2,847,232 bytes323Packer: UPX 3.96 (unpacked for analysis)324325CLASSIFICATION326Family: XMRig Cryptominer (modified)327Variant: Custom build with C2 update mechanism328329FUNCTIONALITY330[*] XMR (Monero) mining via RandomX algorithm331[*] Stratum pool connection for work submission332[*] C2 check-in for configuration updates333[*] Process name masquerading (argv[0] = "[kworker/0:0]")334[*] Competitor process killing (kills other miners)335[*] SSH key injection for re-access336337NETWORK INDICATORS338Mining Pool: stratum+tcp://pool.minexmr[.]com:4444339C2 Server: hxxp://update.malicious[.]com/config340Wallet: 49jZ5Q3b...Monero_Wallet_Address...341342PERSISTENCE343[1] Crontab entry: */5 * * * * /tmp/.X11-unix/.rsync344[2] SSH key added to /root/.ssh/authorized_keys345[3] Systemd service: /etc/systemd/system/rsync-daemon.service346[4] Modified /etc/ld.so.preload for process hiding347348PROCESS HIDING349LD_PRELOAD: /usr/lib/.libsystem.so350Hook: readdir() to hide /tmp/.X11-unix/.rsync from ls351Hook: fopen() to hide from /proc/*/maps reading352```