The Hackers Labs Writeup — BlueeMoon (Spanish)

A continuación, describo la guía de resolución del laboratorio de The Hackers Labs denominado “BlueeMoon”.

Este laboratorio está catalogado con la dificultad “Avanzado” y su autor es “**MeTaN01a**”.

ATENCIÓN

Las herramientas y técnicas utilizadas en la resolución de este laboratorio han sido ejecutadas en un entorno controlado. El autor de esta publicación no se hace responsable del mal uso que se haga de estas, ya que el objetivo final de esta publicación es transmitir conocimientos con fines éticos y educativos.

Resumen de contenido sobre este laboratorio

Tags: Análisis de tráfico de red (PCAP), Forense, *Malvertising, OSINT, `Scripting`*

Antes de comenzar, se indica un resumen de contenido que se puede encontrar en esta guía:

• Análisis de tráfico de red con el objetivo de identificar un incidente acontecido en un entorno corporativo y poder así contestar a una serie de preguntas planteadas.

Reconocimiento inicial (comprimido facilitado)

Este laboratorio proporciona un archivo comprimido el cual contiene un archivo PCAP a analizar.

ls -al The\ Hackers\ Labs\ -\ BlueMoon.zip

unzip The\ Hackers\ Labs\ -\ BlueMoon.zip
ls -al
file BlueMoon.pcap

Nota importante: Como las preguntas a contestar son las que corresponden a las flags concretas del laboratorio, no se va a contestar estas explícitamente, sino mostrando la ubicación donde se encuentran las respuestas según se va redactando la resolución del análisis y sus conclusiones. Además, el objetivo es contestar las preguntas propuestas, por lo que esta guía no está pensada para detallar y abordar cada detalle, acortando así el tiempo de investigación lo máximo posible.

Análisis de tráfico de red (BlueMoon.pcap)

El archivo **BlueMoon.pcap** contiene la captura de tráfico de red durante la ventana del incidente.

Para poder analizarlo, se abre este archivo con Wireshark y se modifica el campo Time para que se muestre la fecha completa.

Cambiar formato de fecha:
View > Time Display Format > Date and Time of Day

Como tal y como indican las propias preguntas, se está tratando con un incidente donde un cliente de Windows se ve infectado, es posible que se trate de algún evento que se haya dado anteriormente y que aparezca públicamente documentado.

Por ello, primero se extraen los posibles recursos maliciosos que puedan considerarse de interés para analizarse.

Por un lado, se extraen las direcciones IP únicas que figuren en el archivo PCAP a un archivo de texto separado.

tshark -r BlueMoon.pcap -T fields -e ip.src -e ip.dst | tr '\t' '\n' | grep -E '^[0-9.]+$' | sort -u > all_ipv4_addresses.txt

Por otro lado, se extraen las URLs base o dominios únicos que figuren en el archivo PCAP a otro archivo de texto separado.

(tshark -r BlueMoon.pcap -Y http.request -T fields -e http.host -e http.request.uri | awk '{print $1 $2}' && tshark -r BlueMoon.pcap -Y tls.handshake.extensions_server_name -T fields -e tls.handshake.extensions_server_name) | tr '\t,' '\n\n' | sed '/^$/d' | awk -F/ '{print $1}' | awk -F? '{print $1}' | awk '/^[a-zA-Z0-9][a-zA-Z0-9.-]*[a-zA-Z0-9]$/' | sort -u > all_base_urls.txt

En este punto se aprovecha VirusTotal para delegar la inspección de posibles recursos maliciosos.

En resumen, VirusTotal es un servicio online de análisis de archivos y enlaces que sirve principalmente para detectar virus, malware y otras amenazas de seguridad.

Referencia (VirusTotal): https://www.virustotal.com

Para delegar por completo y de forma automática el análisis a este servicio, se desarrolla un script en Python aprovechando su API para realizar las consultas pertinentes. Es importante considerar su documentación antes de continuar.

Tener en cuenta que requiere de una cuenta gratuita para obtener la API key correspondiente para poder realizar peticiones.

Referencia (API VirusTotal): https://docs.virustotal.com/reference/overview

El script desarrollado para delegar la detección de recursos maliciosos utilizando la API de VirusTotal es el siguiente:

import requests
import time
import base64

# API key de VirusTotal (requerida)
API_KEY = "TU_API_KEY_DE_VIRUSTOTAL"

# Variables escaneo IPs
VT_IP_SCAN = "https://www.virustotal.com/api/v3/ip_addresses/{}"
INPUT_IP_FILE = "all_ipv4_addresses.txt"
OUTPUT_MALICIOUS_IP_FILE = "malicious_ips.txt"

# Variables escaneo URLs
VT_URL_SCAN = "https://www.virustotal.com/api/v3/urls/{}"
INPUT_URL_FILE= "all_base_urls.txt"
OUTPUT_MALICIOUS_URL_FILE = "malicious_urls.txt"

# Cabeceras HTTP
HEADERS = {
    "accept": "application/json",
    "x-apikey": API_KEY
}

# Tiempo de espera entre peticiones
# Necesario de establecer en el plan gratuito de VirusTotal
SLEEP_TIME = 15

# Emitir petición al escaner correspondiente
def check_item(vt_url, item, type="IP"):
    # En el caso de ser una URL, codificar a Base64
    if type == "URL":
        item = base64.b64encode(item.encode("utf-8")).decode("utf-8").strip("=")

    # Enviar petición
    r = requests.get(vt_url.format(item), headers=HEADERS)

    # Código de estado distinto de 200 => no hay información
    if r.status_code != 200:
        return None

    # Devolver información del último análisis
    data = r.json()["data"]["attributes"]["last_analysis_stats"]
    return data

# Cargar recursos de un archivo concreto
def load_file(filename):
    with open(filename, "r") as f:
        return [line.strip() for line in f if line.strip()]

# Analizar recursos utilizando VirusTotal
def analyze_items(input_file, vt_url, item_type, singular_item_name, plural_item_name, malicious_items_output_file):
    # Cargar recursos de un archivo concreto
    items = load_file(input_file)

    malicious_items = []

    print("******************************************************\n")
    print(f"[+] Comprobando {len(items)} {plural_item_name}...")
    for item in items:
        # Comprobar cada recurso del archivo
        stats = check_item(vt_url, item, item_type)
        if stats:
            # Si sus estadísticas indican que es malicioso
            if stats.get("malicious", 0) > 0:
                # Mostrarlo por pantalla junto a las estadísticas
                print(f"[MALICIOUS {singular_item_name}] {item} -> {stats}")
                # Marcarlo como malicioso
                malicious_items.append(item)
        # Esperar para poder realizar la siguiente petición
        time.sleep(SLEEP_TIME)

    # Una vez analizados todos, guardar en un archivo separado todos los marcados como maliciosos
    with open(malicious_items_output_file, "w") as f:
        f.write("\n".join(malicious_items))

    # Mostrar mensaje de fin de análisis de recursos junto a estadísticas básicas
    print("\n[+] Hecho!")
    print(f"Número de {plural_item_name} maliciosas detectadas: {len(malicious_items)}")

if __name__ == "__main__":
    print("Iniciando escaneo de recursos con VirusTotal...")

    # Delegar escaneo de IPs a VirusTotal y detectar todas las maliciosas
    analyze_items(INPUT_IP_FILE, VT_IP_SCAN, "IP", "IP", "IPs", OUTPUT_MALICIOUS_IP_FILE)

    # Delegar escaneo de URLs a VirusTotal y detectar todas las maliciosas
    analyze_items(INPUT_URL_FILE, VT_URL_SCAN, "URL", "URL", "URLs", OUTPUT_MALICIOUS_URL_FILE)

Una vez definido adecuadamente, se ejecuta este script. Teniendo en cuenta el tiempo de espera mínimo necesario entre ejecuciones debido al plan gratuito y considerando que la respuesta de cada petición sea inmediata, la ejecución puede demorarse aproximadamente 1 hora. Durante este tiempo se aprovecha para continuar analizando de forma manual el archivo PCAP y obtener así más contexto de lo acontecido.

Una vez este termina su ejecución, se pueden comprobar una serie de recursos se han marcado como maliciosos, lo que reduce bastante el número de recursos a investigar.

Se puede comprobar que se reporta una IP en particular que destaca por su valor en el apartado malicious, y que se repite además esta característica también como URL de la misma forma. Por ello, se comienza a investigar por esta.

python3 check_for_malicious_resources.py
(1 hora después finaliza la ejecución)

Durante la inspección manual, se obtienen algunos datos de interés que pueden ayudar a continuar investigando y obtener nuevos hallazgos.

Entorno: Corporativo (Directorio Activo)
Red interna (CIDR): 10.1.17.0/24
Controlador de dominio: 10.1.17.2
Dominio: bluemoontuesday.com

Para continuar analizando el PCAP con la nueva información, se filtra por esta IP maliciosa para obtener el tráfico de red generado por esta. A continuación, se muestran las conversaciones generadas, comprobando que estas solo muestran tráfico desde un cliente del Directorio Activo hacia esta IP maliciosa. Este debe ser el cliente infectado.

Filtro: ip.addr == <RECORTADO>
Navegar a Statistics > Conversations

Tras inspeccionar los streams generados en orden cronológico, el primero de ellos muestra una petición que parece solicitar la descarga de un recurso.

Click derecho en el stream con ID 60 > Apply as Filter > Selected > Filter on stream id

La información se encuentra en texto plano, ya que las solicitudes se han realizado a través de HTTP. Por ello, se procede a revisar el stream TCP de la descarga de la siguiente forma:

Click derecho en el paquete 5031 > Follow > TCP Stream

Esto filtra por el stream 60 concretamente, lo que muestra la carga de un componente que contiene un script en VBScript, que parece encargarse de descargar nuevos recursos desde la misma IP maliciosa.

Filtro: tcp.stream eq 60

Comprobando el siguiente stream que también corresponde a esta IP maliciosa, se puede comprobar que realiza una nueva descarga.

Filtro: tcp.stream eq 61

Esta vez de un script en PowerShell codificado en Base64 y mínimamente ofuscado.

Comprobando el mismo stream, se termina detectando un script en PowerShell que parece ser el encargado de continuar realizando descargas de distintos recursos sobre el sistema infectado.

En este punto se decide continuar investigando sobre el script en PowerShell denominado “29842.ps1”. Como era de esperar, este ha sido reportado como malicioso.

Reporte sobre 29842.ps1: https://any.run/report/b8ce40900788ea26b9e4c9af7efab533e8d39ed1370da09b93fcf72a16750ded/09aed4c9-62de-42c7-93e4-4498967f8113

Tras investigar más en detalle sobre este archivo, resulta que corresponde a una campaña de Malvertising relacionada con Microsoft Teams ocurrida en Enero de 2025.

Campaña de Malvertising sobre Teams: https://cybersecuritynews.com/fake-microsoft-teams-page-drops-malware-on-windows/

Tras continuar investigando, se detectan coincidencias en la resolución de dominios con alguna de las IPs marcadas como maliciosas, resolviendo a otro de los dominios marcado como malicioso.

Pasa exactamente los mismo con otro dominio en particular, el cual parece generar mucho más tráfico que el anterior, y que por como aparece escrito parece utilizar una técnica denominada typosquatting para aprovechar errores de escritura de usuarios para que caigan en una web falsa.

Respuesta de la pregunta 5 — Probable sitio de descarga de malware

Pero al no disponer de los secretos de sesión TLS asociados a este tráfico en particular (archivo *keys.log*), no es posible descifrar y continuar analizando que ocurre dentro del tráfico asociado a estos dominios.

Sin embargo, tras continuar investigando más en detalle, resulta que parece corresponder a otra campaña de Malvertising, esta vez relacionada con Google Authenticator ocurrida también en Enero de 2025.

Campaña de malvertising sobre Google Authenticator: https://cybernews.com/security/hackers-stealing-google-ads-accounts-publish-fake-ads/

Tras continuar analizando el tráfico de red TLS, se revisan estadísticas concretamente asociadas a este tráfico.

Filtro: tls

Revisar picos de tráfico: 
Statistics > I/O Graphs

Al filtrar el tráfico en este rango en particular, se detecta en este caso un único dominio nada sospechoso, y que oficialmente y de forma legítima se utiliza como canal de notificaciones push.

El dominio encontrado aparece en el tráfico TLS asociado al momento en que se accede a la página falsa de Google Authenticator. Aunque es un servicio legítimo de notificaciones push, en este caso se observa como parte del flujo de actividad generado tras la interacción con la página fraudulenta, justo antes de los picos de tráfico TLS observados previamente.

Filtro: tls && frame.time_relative >= 5  && frame.time_relative <= 10

Respuesta de la pregunta 4 — Probable nombre de dominio a página falsa

A pesar de que los dominios con apariencia sospechosa apuntan a los dominios previamente marcados como maliciosos, es muy probable que el detonante pueda estar relacionado con este último dominio en particular.

Continuando con la investigación del tráfico SMB y el tráfico generado por el cliente infectado, se termina detectando el nombre asociado al cliente Windows infectado.

Filtro: smb && ip.src == <RECORTADO> (ordenar por número de paquete)

Respuesta de la pregunta 3 — Nombre del cliente infectado

Al ser un entorno de Directorio Activo, la autenticación puede realizarse mediante Kerberos.

Siendo este el caso, es posible recuperar el nombre de la cuenta, ya que en cualquier mensaje AS (Authentication Service), el nombre de la cuenta se encuentra en texto plano, dentro los campos de cabecera.

El nombre de la cuenta se encuentra en el campo cname (Client Name) dentro de la cabecera del mensaje. Esto permite al KDC identificar el usuario solicitante y procesar la autenticación antes de emitir un ticket cifrado.

Referencia: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-kile/b4af186e-b2ff-43f9-b18e-eedb366abf13

Filtro: kerberos.as_rep_element

Respuesta de las preguntas 1,2 y 6 — Dirección IP, MAC y nombre de usuario del cliente infectado

Resumen ejecutivo sobre los hallazgos realizados

Basada en la información recabada, al parecer el cliente ha sido víctima de dos campañas de Malvertising organizadas por el misma grupo de ciberdelincuentes, con el objetivo de secuestrar tanto su máquina de trabajo (falso Microsoft Teams) como su cuenta de Google (falso Google Authenticator).

¿Te gustó esta publicación? Sígueme y descubre más en mi blog principal: https://pyth0nk1d.medium.com