Analisis de Firmware: Binwalk, Extraccion y Reverse Engineering

Firmware: la superficie de ataque invisible

Miles de millones de dispositivos IoT ejecutan firmware que rara vez se actualiza y que a menudo contiene vulnerabilidades criticas. Routers domesticos, camaras IP, smart TVs, controladores industriales y dispositivos medicos comparten un patron comun: firmware basado en Linux con servicios configurados de forma insegura.

El analisis de firmware combina tecnicas de analisis de binarios (ELF en la mayoria de casos) con extraccion de sistemas de archivos, analisis de configuraciones y emulacion. Es un campo donde las herramientas especializadas como binwalk son indispensables.

Estructura tipica de una imagen de firmware

Una imagen de firmware es un archivo binario monolitico que contiene todo lo necesario para el dispositivo:

Componente	Descripcion	Posicion tipica
Bootloader	U-Boot, RedBoot, CFE	Inicio del archivo
Kernel	Linux kernel comprimido	Despues del bootloader
Root filesystem	Sistema de archivos con el OS	Mayor parte del firmware
NVRAM / Config	Configuracion del dispositivo	Final o particion separada
Trailer / Checksum	CRC32, MD5 de verificacion	Ultimos bytes

Obtencion del firmware

Antes de analizarlo, hay que obtener la imagen de firmware:

Metodo	Descripcion	Dificultad
Descarga del fabricante	Pagina de soporte, updates	Facil
Captura de actualizacion	Interceptar trafico de update	Media
Dump via JTAG/SWD	Conectar al debug port de la PCB	Alta
Dump via SPI flash	Leer el chip de flash directamente	Alta
Dump via UART	Acceso a consola serial	Media
Repositories publicos	firmware.wiki, FACT database	Facil

Binwalk: la herramienta fundamental

Binwalk escanea archivos binarios buscando firmas de formatos conocidos. Su base de datos incluye cientos de firmas de sistemas de archivos, formatos de compresion, bootloaders y kernels.

Escaneo basico

# Escanear buscando firmas
binwalk firmware.bin

# Salida tipica:
# DECIMAL       HEXADECIMAL     DESCRIPTION
# 0             0x0             uImage header, header size: 64 bytes
# 64            0x40            LZMA compressed data
# 1048576       0x100000        Squashfs filesystem, little endian, version 4.0
# 3145728       0x300000        JFFS2 filesystem, little endian

Extraccion automatica

# Extraer todos los componentes detectados
binwalk -e firmware.bin

# Extraer recursivamente (extrae dentro de lo extraido)
binwalk -Me firmware.bin

# Resultado: directorio _firmware.bin.extracted/
# Contiene el sistema de archivos, kernel descomprimido, etc.

Analisis de entropia

# Grafico de entropia
binwalk -E firmware.bin

# La entropia ayuda a identificar:
# - Regiones comprimidas (entropia alta, ~7.0-7.5)
# - Regiones cifradas (entropia muy alta, ~7.8-8.0)
# - Datos en claro (entropia baja-media)
# - Regiones vacias (entropia 0)

Opciones avanzadas

# Buscar solo un tipo especifico
binwalk -y "squashfs" firmware.bin

# Excluir falsos positivos
binwalk -x "jpeg" firmware.bin

# Analisis de opcodes (instrucciones de CPU)
binwalk -A firmware.bin
# Identifica la arquitectura: ARM, MIPS, x86, PPC

# Comparar dos firmwares
binwalk -W firmware_v1.bin firmware_v2.bin

Sistemas de archivos en firmware

SquashFS

El mas comun en routers y dispositivos Linux embebidos. Es de solo lectura y comprimido:

# Extraer SquashFS
unsquashfs -d output_dir squashfs_image

# Si binwalk ya lo extrajo:
ls _firmware.bin.extracted/squashfs-root/
# bin/  dev/  etc/  lib/  proc/  sbin/  tmp/  usr/  var/  www/

JFFS2

Sistema de archivos journaled para flash NOR:

# Extraer JFFS2 requiere herramientas especiales
jefferson jffs2_image -d output_dir

# O con binwalk
binwalk -e firmware_con_jffs2.bin

CramFS

Sistema de archivos comprimido de solo lectura (legacy):

# Extraer CramFS
cramfsck -x output_dir cramfs_image

YAFFS2

Para flash NAND:

# Extraer YAFFS2
unyaffs yaffs2_image output_dir

Analisis del sistema de archivos extraido

Una vez extraido el rootfs, el analisis sigue un patron sistematico:

Credenciales hardcodeadas

# Buscar en /etc/passwd y /etc/shadow
cat squashfs-root/etc/passwd
cat squashfs-root/etc/shadow

# Buscar passwords en configuraciones
grep -r "password\|passwd\|pass=" squashfs-root/etc/
grep -r "admin\|root\|user" squashfs-root/etc/

# Buscar claves SSH/SSL
find squashfs-root/ -name "*.pem" -o -name "*.key" -o -name "id_rsa"

Servicios y puertos

# Archivos de inicio de servicios
ls squashfs-root/etc/init.d/
cat squashfs-root/etc/init.d/rcS

# Configuracion de servicios de red
cat squashfs-root/etc/inetd.conf
cat squashfs-root/etc/xinetd.conf

# Buscar telnet, SSH, FTP habilitados
grep -r "telnetd\|dropbear\|vsftpd\|ftpd" squashfs-root/etc/

Interfaz web

# Los CGI scripts suelen tener vulnerabilidades
find squashfs-root/www/ -name "*.cgi" -o -name "*.asp" -o -name "*.lua"

# Buscar command injection en scripts CGI
grep -r "system\|popen\|exec\|eval\|os.execute" squashfs-root/www/

# Buscar autenticacion debil
grep -r "admin\|password\|check_auth" squashfs-root/www/

Binarios sospechosos

# Listar binarios ELF
find squashfs-root/ -type f -executable | xargs file | grep ELF

# Buscar binarios no estandar
find squashfs-root/ -type f -executable | while read f; do
    basename_f=$(basename "$f")
    # Listar binarios que no son tipicos de BusyBox
    if ! grep -q "$basename_f" standard_busybox_applets.txt 2>/dev/null; then
        echo "Non-standard: $f"
    fi
done

# Analizar un binario especifico
readelf -h squashfs-root/usr/bin/suspicious_binary
strings squashfs-root/usr/bin/suspicious_binary | grep -iE "http|socket|exec|shell"

Claves criptograficas compartidas

# Certificados SSL
find squashfs-root/ -name "*.crt" -o -name "*.cert"
openssl x509 -in squashfs-root/etc/ssl/cert.pem -text -noout

# Verificar si la clave privada esta incluida (critico)
find squashfs-root/ -name "*.key" -o -name "*.pem" | \
    xargs grep -l "PRIVATE KEY"

Emulacion con QEMU

QEMU permite ejecutar binarios de firmware sin el hardware real:

Emulacion de un binario individual

# Instalar QEMU para la arquitectura correcta
sudo apt install qemu-user-static

# Emular binario MIPS (comun en routers)
qemu-mipsel-static -L squashfs-root/ squashfs-root/usr/bin/httpd

# Emular binario ARM
qemu-arm-static -L squashfs-root/ squashfs-root/usr/sbin/some_service

# Con strace
qemu-mipsel-static -strace -L squashfs-root/ squashfs-root/usr/bin/target

Emulacion de sistema completo

Para emular el firmware completo (con networking):

# firmadyne automatiza la emulacion de firmware de routers
git clone https://github.com/firmadyne/firmadyne.git
cd firmadyne

# Extraer firmware
python3 sources/extractor/extractor.py -b brand -sql 127.0.0.1 \
    -np -nk firmware.bin images/

# Configurar networking
./scripts/inferNetwork.sh 1
./scripts/makeNetwork.sh 1

# Ejecutar
./scratch/1/run.sh

# Acceder a la interfaz web emulada
# http://192.168.0.1 (o la IP inferida)

FACT (Firmware Analysis and Comparison Tool)

Plataforma web para analisis automatizado de firmware:

# FACT automatiza:
# - Extraccion de sistema de archivos
# - Identificacion de componentes de software (BusyBox, OpenSSL version)
# - Busqueda de vulnerabilidades conocidas (CVEs)
# - Busqueda de credenciales hardcodeadas
# - Comparacion entre versiones de firmware
# - Analisis de criptografia

Vulnerabilidades comunes en firmware

Command Injection en CGI

// Vulnerable: input del usuario pasa directo a system()
void handle_ping(char *ip_address) {
    char cmd[256];
    // VULNERABLE: sin sanitizar ip_address
    snprintf(cmd, sizeof(cmd), "ping -c 4 %s", ip_address);
    system(cmd);
}
// Payload: 192.168.1.1; cat /etc/shadow

# Buscar patrones de command injection
grep -rn "system\|popen\|exec" squashfs-root/www/cgi-bin/
grep -rn "sprintf.*\"%s\"" squashfs-root/www/cgi-bin/

Buffer overflow en servicios

# Buscar funciones inseguras
grep -rn "strcpy\|strcat\|gets\|sprintf" squashfs-root/usr/bin/
# Estos indican posibles buffer overflows

Actualizaciones sin firma

# Buscar proceso de actualizacion
grep -r "upgrade\|update\|flash" squashfs-root/etc/init.d/
grep -r "mtd_write\|flashcp" squashfs-root/usr/sbin/

# Si no hay verificacion de firma digital, cualquier firmware puede instalarse

Backdoors del fabricante

# Backdoors comunes en routers
# 1. Puerto de debug abierto
grep -r "32764\|7329\|8888" squashfs-root/etc/

# 2. Cuenta de servicio oculta
cat squashfs-root/etc/passwd | grep -v "nologin\|false"

# 3. Binarios de acceso remoto no documentados
find squashfs-root/ -name "*backdoor*" -o -name "*remote*" -o -name "*tplink*"

Herramientas complementarias

Herramienta	Funcion
binwalk	Escaneo y extraccion de firmware
firmwalker	Script de analisis automatizado del filesystem
FACT	Plataforma web de analisis de firmware
firmadyne	Emulacion automatizada de firmware
QEMU	Emulacion de binarios y sistemas
Ghidra	Decompilacion de binarios ARM/MIPS
jefferson	Extraccion de JFFS2
sasquatch	SquashFS con soporte para variantes no estandar
ubi_reader	Extraccion de UBI/UBIFS
BAP (Binary Analysis Platform)	Analisis binario academico

Script de triaje automatizado de firmware

#!/bin/bash
# firmware_triage.sh - Triaje basico de firmware

FIRMWARE="$1"
OUTPUT="firmware_analysis"

mkdir -p "$OUTPUT"

echo "=== Firmware Triage Report ==="
echo "File: $FIRMWARE"
echo "Size: $(stat -f%z "$FIRMWARE" 2>/dev/null || stat -c%s "$FIRMWARE") bytes"
echo "SHA256: $(sha256sum "$FIRMWARE" | cut -d' ' -f1)"
echo

echo "--- Binwalk Scan ---"
binwalk "$FIRMWARE" | tee "$OUTPUT/binwalk_scan.txt"

echo
echo "--- Architecture Detection ---"
binwalk -A "$FIRMWARE" | head -20

echo
echo "--- Entropy Analysis ---"
binwalk -E "$FIRMWARE" 2>/dev/null

echo
echo "--- Extracting ---"
binwalk -Me "$FIRMWARE" -C "$OUTPUT/"

# Buscar en el filesystem extraido
ROOTFS=$(find "$OUTPUT" -name "squashfs-root" -type d 2>/dev/null | head -1)
if [ -n "$ROOTFS" ]; then
    echo
    echo "--- Filesystem Analysis ---"
    echo "Root filesystem found: $ROOTFS"

    echo
    echo "Passwords:"
    cat "$ROOTFS/etc/passwd" 2>/dev/null
    cat "$ROOTFS/etc/shadow" 2>/dev/null

    echo
    echo "SSH Keys:"
    find "$ROOTFS" -name "*.pem" -o -name "*.key" -o -name "id_rsa" 2>/dev/null

    echo
    echo "Web interface files:"
    find "$ROOTFS/www" -name "*.cgi" -o -name "*.asp" 2>/dev/null | head -20

    echo
    echo "Potential command injection:"
    grep -rn "system\|popen\|exec" "$ROOTFS/www/" 2>/dev/null | head -20
fi

Casos reales de vulnerabilidades en firmware

Mirai y variantes

Mirai escanea dispositivos IoT con credenciales por defecto (62 combinaciones username/password) y los recluta en una botnet. El firmware de millones de dispositivos incluia estas credenciales sin opcion de cambio.

VPNFilter

Malware sofisticado que infectaba routers de multiples fabricantes. Sobrevivia reboots escribiendo en la particion NVRAM. Capacidades: interceptar trafico, inyectar contenido web, destruir el dispositivo (brick).

TheMoon

Botnet que explotaba vulnerabilidades de command injection en la interfaz web de routers Linksys. El CGI script no sanitizaba parametros del usuario antes de pasarlos a system().

Conclusion

El analisis de firmware combina habilidades de analisis de binarios (ELF), analisis de sistemas Linux y seguridad de redes. Binwalk es la puerta de entrada, pero el analisis real empieza despues de la extraccion: buscar credenciales hardcodeadas, servicios inseguros, command injection en CGI scripts y backdoors del fabricante. Con miles de millones de dispositivos IoT vulnerables, el firmware analysis es una habilidad cada vez mas demandada en equipos de CTI y red teams.