Spamtrap: la trampa para recolectar correos maliciosos y de spam

Generalmente, salvo grandes empresas que cuentan con grandes presupuestos, pocas son las aplicaciones prácticas para disponer de un spamtrap en un servidor propio. Los costes altos, la infraestructura que necesitamos, el número de recursos y el tiempo para procesar la información y separar la paja del metal puede hacerse eterno… pero eso no quita que pensemos que mola mucho tener nuestro propio spamtrap, ver como se comportan los malos en sus campañas de fraude, analizar los casos de uso, los comportamientos, las variaciones y, en algunos casos, hasta los IoCs de malware.

Todo esto nos ha hecho decidirnos por llevar a cabo y hacer efectiva esta maravilla que ahora os vamos a mostrar. Aplicaciones prácticas no sabemos si tendrá para un uso particular, pues esto es más una labor de investigación, pero si os quedáis, seguro que podremos transmitiros algo de nuestro poco conocimiento en este mundo tan grande que supone la ciberseguridad.

Preparaciones previas

Vamos a usar una máquina Linux que deberá esta actualizada, preferiblemente ser Debian, sin imágenes pre-configuradas (Kali, ParrotOS…) sino un Debian normal y como viene por defecto. Se recomienda encarecidamente el uso de una máquina virtual y segmentación de red. Lo que vamos a hacer puede llevarnos a una auto-infección e incluso una propagación del malware por nuestra red doméstica. Sería recomendable utilizar algún tipo de firewall o medida adicional de seguridad. Pero esto os lo vamos a dejar a vosotros… algo habrá que experimentar, ¿no?

Configuración de dominio

Registra algún dominio, compra o consigue uno de forma gratuita, o usa uno que tengas y quieras dedicar para esto. Vamos a necesitar un dominio que podamos configurar a nivel de DNS como nosotros queramos. Sin trabas, sin filtros adicionales, como por ejemplo los de Gmail, que cuenta ya con sus propios filtros de spam. De esta manera nos aseguraremos de que nos va a llegar toda la chicha, todo el contenido de los correos, malware y enlaces.

Para que esto funcione deberemos hacer que los MX del dominio apunten a nuestro servidor Linux. Os recomendamos encarecidamente hacer uso de algún panel como HestiaCP (podéis ver este panel en las imágenes anteriores), que se instala muy fácilmente para configurar certificados, dominios, dns y firewall de forma sencilla, eso no quita que debamos aprender a hacerlo de forma manual y por eso vamos a dejar algunos de los pasos a continuación por si alguien quiere hacerlo sin HestiaCP, pero nos meteríamos en muchos pasos… por lo que no vamos a dar todas las soluciones.

Instalación del servidor de correo

Para el servidor de correo vamos a usar Dovecot y Exim4, aunque podemos usar cualquier tipo de servidor de correo que prefiramos. Adicionalmente, vamos a instalar Roundcube, porque en algún momento vamos a querer entrar a ver nuestros correos por vista web, como si fuera un Gmail o un Outlook.

Para ello debemos hacer lo siguiente:

sudo apt-get install dovecot-core dovecot-imapd
sudo apt-get install exim4

Una vez tengamos esto vamos a necesitar un correo catch-all, aunque esta parte la vamos a hacer desde nuestro HestiaCP que nos hace ya una instalación de todo lo que necesitamos para poder configurar nuesto spamtrap, dominios, etc.

Os vamos a dejar experimentar un poco para que podáis pegaros con ello y aprender como funciona todo, aunque muchos de vosotros seguramente lo sepáis mejor que nosotros.

Instalación ClamAV

Ahora vamos a instalar el que será nuestro antivirus. Vamos a hacer uso de un AV opensource en este caso, siendo por tanto de uso gratuito y muy configurable. Instalamos ClamAV y el daemon:

sudo apt-get install clamav clamav-daemon

Actualizamos la base de datos de virus (recuerda parar el daemon antes de actualizarlo):

sudo freshclam

Finalmente reiniciamos el servicio:

sudo systemctl start clamav-freshclam

Si queremos que se actualice de forma periódica la base de datos podemos hacer una automatización mediante un cron job invocando al demonio de freshclam (queda muy épico decir «invocando el demonio», no podía resistirme). Además, siempre le podemos poner un mensajito que ponga: «La base de datos de virus ha sido actualizada».

Antes de continuar vamos a comprobar una serie de cosas. La primera es si ripmime y jq están instalados (generalmente si). Esto nos permitirá extraer los archivos adjuntos de los correos y trabajar con ficheros JSON respectivamente. Podemos hacer un apt-get install para ver si los descarga o ya se encuentran en el sistema.

Lo siguiente que vamos a hacer es observar dónde se encuentra nuestra carpeta de almacenamiento de los correos. En nuestro caso se encuentra en la ruta home, dentro de nuestro usuario, a su vez dentro de nuestro dominio, a su vez dentro del usuario de correo (home<user<dominio.com<examplemail). Pero dependerá de vuestro servidor y de los usuarios que tengáis y de si estáis usando HestiaCP o no.

Si observamos esta imagen veremos que hay 3 carpetas a las cual hacemos un listado de directorio. Bien, esto es porque queríamos que vierais que en la carpeta new, se encuentran los nuevos mails, ahora no se ve ninguno, pero nosotros tenemos más de 166 en bandeja de entrada. Algo no cuadra ¿no?

En la carpeta tmp estarían los adjuntos, no hay tampoco. Bueno, y ¿dónde están mis correos? pues bien, como tenemos abierto Roundcube, los correos han pasado a la carpeta cur y se han movido de new. Según lo que hemos podido averiguar, esto se debe a un proceso interno que realiza Rouncube en el cual los mueve de cierta forma siempre y cuando tengamos habierto Roundcube.

Sabiendo todo esto podemos pasar al siguiente paso.

Script para analizar los mails

Es el momento de empezar a programar. Ya conocemos las rutas, conocemos las tecnologías y, sabemos que queremos conseguir analizar los correos entrantes, estén leídos o no, para después sacar una serie de estadísticas. Por ejemplo, queremos saber los hashes de los ficheros, queremos conocer los remitentes, queremos saber cuál es el cuerpo del mensaje… todo esto para luego poder hacernos un dashboard y pintar todos estos datos de forma sencilla para poder trabajar con ellos.

En nuestro caso lo vamos a dejar en un formato JSON. Pero podríamos trabajar, por ejemplo, en una exportación para OpenCTI, Splunk, o cualquier otra herramienta similar. Os recomendamos el Podcast: entrevista a Carlos Loureiro en el que hablamos sobre MISP, The Hive, Cortex y OpenCTI.

Como consejo, observar el espacio que os queda con un free -h ya que consume algunos recursos ejecutar y actualizar ClamAV aunque no pensamos que se necesiten más allá de 1GB sigue siendo difícil y problemático instalarlo en un servidor con 1GB de RAM, ya que no es capaz de iniciar el proceso si estamos ejecutando otras cosas.

Nota: Finalmente hemos tenido que aumentar a 2GB de RAM, ahora parece que funciona la actualización.

Vamos a ver el código:

#!/bin/bash

# Directorios, cambiadlos con los vuestros claro
MAIL_DIR=""
ATTACHMENTS_DIR=""
PROCESSED_ATTACHMENTS_DIR=""
PROCESSED_IDS_FILE=""
JSON_OUTPUT=""

mkdir -p "$ATTACHMENTS_DIR"
mkdir -p "$PROCESSED_ATTACHMENTS_DIR"
touch "$PROCESSED_IDS_FILE"
touch "$JSON_OUTPUT"

# Inicializar JSON si está vacío
if [ ! -s "$JSON_OUTPUT" ]; then
    echo "[]" > "$JSON_OUTPUT"
fi

# Función para procesar directorios de correo
process_mail_dir() {
    local mail_dir=$1
    for MAILFILE in "$mail_dir"/{new,cur}/*; do
        if [ ! -f "$MAILFILE" ]; then
            continue
        fi

        # Extraer el ID del mensaje del correo, varias opciones de grep que hemos ido probando
        local message_id
        #message_id=$(grep -m 1 -hI '^Message-ID:' "$MAILFILE" | sed 's/Message-ID: <\([^>]*\)>/\1/' | tr -d '[:space:]')
        message_id=$(grep -i -m 1 -hI '^Message-ID:' "$MAILFILE" | sed -E 's/.*Message-ID: *<([^>]+)>.*/\1/i')
        
        if [ -z "$message_id" ]; then
            echo "No se pudo encontrar un ID de mensaje válido para el archivo: $MAILFILE"
            continue
        fi

        # Verificar si el ID del mensaje ya ha sido procesado para no repetirse en el análisis
        if grep -Fxq "$message_id" "$PROCESSED_IDS_FILE"; then
            echo "Mensaje ya procesado: $message_id"
            continue
        fi

        # Extraer archivos adjuntos del correo electrónico
        ripmime -i "$MAILFILE" -d "$ATTACHMENTS_DIR"

        # Escanear cada archivo adjunto y calcular el hash
        for FILE in "$ATTACHMENTS_DIR"/*; do
            if [ -f "$FILE" ]; then
                local hash
                hash=$(sha256sum "$FILE" | cut -d ' ' -f 1)
                local clamscan_output
                clamscan_output=$(clamscan "$FILE")
                local malware_detected="false"
                local malware_type=""
                
                if ! grep -q 'Infected files: 0' <<< "$clamscan_output"; then
                    malware_detected="true"
                    malware_type=$(echo "$clamscan_output" | grep FOUND | cut -d ' ' -f 2)
                fi

                # Crear entrada JSON
                local json_entry
                json_entry=$(jq -n \
                                --arg ts "$(date +%F_%T)" \
                                --arg id "$message_id" \
                                --arg file "$FILE" \
                                --arg hash "$hash" \
                                --arg md "$malware_detected" \
                                --arg mt "$malware_type" \
                                '{
                                    timestamp: $ts,
                                    message_id: $id,
                                    file: $file,
                                    hash: $hash,
                                    malware_detected: $md,
                                    malware_type: $mt
                                }')

                # Añadir el JSON al archivo
                local temp_json
                temp_json=$(mktemp)
                if jq ". += [$json_entry]" "$JSON_OUTPUT" > "$temp_json"; then
                    mv "$temp_json" "$JSON_OUTPUT"
                else
                    echo "Error al añadir datos al archivo JSON para el mensaje con ID: $message_id"
                    rm -f "$temp_json"
                fi

                # Mover archivos adjuntos procesados para referencia futura
                mv "$FILE" "$PROCESSED_ATTACHMENTS_DIR/"
            fi
        done

        # Agrega el ID del mensaje al archivo de control
        echo "$message_id" >> "$PROCESSED_IDS_FILE"
    done
}

process_mail_dir "$MAIL_DIR"

echo "Proceso terminado :)"

Con esto ya se analizan los ficheros y tenemos un JSON con la información para poder procesarla posteriormente. Podemos hacer que se ejecute una vez al día, o bien cada diez minutos, aquí ya decide cada uno según necesidades. Eso sí, el script tarda un buen rato en ejecutarse, habrá que tener paciencia e ir a por un café. Sobre todo las primeras veces y más si disponemos de muchos correos por analizar.

Llegados a este punto y tras diversos trasteos hemos implementado algunas mejoras en el proceso. Hemos modificado el script para que extraiga las urls del cuerpo del correo, hemos configurado la parte de clamav para que pueda bajarse archivos de dichas URLs, en caso de que sean URLs de descarga claro y hemos generado un JSON más grande con toda esta información. Os dejamos experimentar con vuestra imaginación y adaptar el script como queráis. Dejadnos vuestras mejoras o vuestras dudas en los comentarios, nos hace mucha ilusión poder escucharos.

Ahora, con estas modificaciones, podemos ver dominios contenidos en los correos, los que más se repiten, analizar campañas más fácilmente y sobre todo tener más muestras de malware. Para que esto se pueda ver de un vistazo hemos programado unos dashboards. Primero os vamos a enseñar el de la prueba de concepto que sería el que estamos usando ahora y luego, vamos a ver otro ejemplo de spamtrap (aunque se queda más en spam que en otra cosa), que lleva activo y en nuestro servidor más de un año.

Dashboard de resultados

En primer lugar vamos a ver el dashboard de los resultados de las pruebas de detección de malware, este es algo más básico y prácticamente sin florituras. Para poder llevarlo a cabo hemos usado la librería «canvas» y «boostrap» para poner estilos más rápidamente.

Con esto podemos gestionar ya bastantes casos de uso, aunque podemos sacar más estadísticas como los servidores de envío de correo que más recibimos, el top de asuntos que recibimos… esto puede ser interesante para relacionar campañas a asuntos de mail en concreto y remitentes… os dejamos algunas imágenes a continuación y, veréis que hemos recibido algún correo de spam de un tal S4ur0n. Bien, este correo es malicioso, pero no hemos conseguido hacer la descarga efectiva, al acceder a la web nos saca un Forbiden y al script también. Esto puede ser porque o bien ya está caída la página cuando hemos hecho las pruebas o bien porque necesitamos alterar los user-agents, IPs o el referer… pero eso es otra historia para otro día. Esperamos que hoy, en esencia, os haya quedado claro al menos lo básico sobre el spamtrap y que podáis trastear con ello.

¿Cómo consigo más correos de spam?

La táctica más común es caer en los casos de fraude, así que hagamos todo lo posible por agrandar las bases de datos de los malos con nuestros correos en ellas. Así nos llegarán muchos más correos con este tipo de contenido.

Si has llegado hasta aquí, recuerda que nos ayudas mucho compartiendo el artículo y bueno, como recompensa vamos a dejarte un enlace a github con algunos de los scripts modificados y el código del dashboard para que puedas trastear. Se pueden hacer muchas mejoras, esto ha sido un prueba de concepto rápida y lo más sencilla posible, os dejamos a vosotros la parte avanzada porque esto nace de la comunidad, para la comunidad.

Enlace a github aquí.