1. POST /jsproxy with the 40-byte Curve25519 handshake
2. Parse session ID and server public key
3. Derive the RouterOS WebFig session keys
4. Initialize RouterOS WebFig RC4 (including RC4-drop-768)
5. Construct a real WebFig M2 message
6. Construct the real encrypted session frame
7. Send only a benign empty M2 request
8. Validate / display the response without attempting file access

python3 jsproxy_safe_poc.py 192.0.2.10
python3 jsproxy_safe_poc.py 192.0.2.10 --port 80
python3 jsproxy_safe_poc.py http://192.0.2.10:8080

lines = []

for off in range(0, len(data), width):
    chunk = data[off:off + width]
    hexpart = " ".join(f"{x:02x}" for x in chunk)
    lines.append(f"{off:04x}: {hexpart}")

return "\n".join(lines)

if len(u) != 32:
    raise ValueError("u-coordinate must be 32 bytes")

k = bytearray(priv)

# RFC 7748 scalar clamping
k[0] &= 248
k[31] &= 127
k[31] |= 64

scalar = int.from_bytes(k, "little")

x1 = int.from_bytes(u, "little") & ((1 << 255) - 1)

x2 = 1
z2 = 0

x3 = x1
z3 = 1

swap = 0

for t in range(254, -1, -1):
    kt = (scalar >> t) & 1

    swap ^= kt

    if swap:
        x2, x3 = x3, x2
        z2, z3 = z3, z2

    swap = kt

    a = (x2 + z2) % P
    aa = (a * a) % P

    b = (x2 - z2) % P
    bb = (b * b) % P

    e = (aa - bb) % P

    c = (x3 + z3) % P
    d = (x3 - z3) % P

    da = (d * a) % P
    cb = (c * b) % P

    x3 = ((da + cb) ** 2) % P

    z3 = (
        x1 *
        ((da - cb) ** 2)
    ) % P

    x2 = (aa * bb) % P

    z2 = (
        e *
        (aa + A24 * e)
    ) % P

    if swap:
        x2, x3 = x3, x2
        z2, z3 = z3, z2

result = (
    x2 *
    pow(z2, P - 2, P)
) % P

return result.to_bytes(32, "little")

private = os.urandom(32)

basepoint = b"\x09" + b"\x00" * 31

public = x25519(private, basepoint)

return private, public

def __init__(self, key):
    self.S = list(range(256))
    self.i = 0
    self.j = 0

    self.set_key(key)

def set_key(self, key):

    if not key:
        raise ValueError("RC4 key cannot be empty")

    S = self.S

    j = 0

    for i in range(256):
        j = (
            j +
            key[i % len(key)] +
            S[i]
        ) & 0xff

        S[i], S[j] = S[j], S[i]

    self.i = 0
    self.j = 0

    # RouterOS WebFig uses RC4-drop-768.
    for _ in range(768):
        self.gen()

def gen(self):

    S = self.S

    self.i = (self.i + 1) & 0xff

    self.j = (
        self.j +
        S[self.i]
    ) & 0xff

    S[self.i], S[self.j] = (
        S[self.j],
        S[self.i]
    )

    return S[
        (S[self.i] + S[self.j]) & 0xff
    ]

def crypt(self, data):

    out = bytearray(len(data))

    for n, value in enumerate(data):
        out[n] = value ^ self.gen()

    return bytes(out)

if len(master_key) != 32:
    raise ValueError("master key must be 32 bytes")

value = bytearray(master_key)

# WebFig:
#
# for(let i=0;i<40;++i)
#     v.push(0);

value.extend(b"\x00" * 40)

if is_send:
    value.extend(MAGIC_SEND)
else:
    value.extend(MAGIC_RECV)

value.extend(b"\xf2" * 40)

return hashlib.sha1(value).digest()[:16]

def __init__(self, host, port, ssl_enabled=False, timeout=10):

    self.host = host
    self.port = port
    self.ssl_enabled = ssl_enabled
    self.timeout = timeout

def request(self, body):

    headers = {
        "Content-Type": "msg",
        "Accept-Language": "",
        "Connection": "close",
    }

    if self.ssl_enabled:

        context = ssl.create_default_context()

        # Useful for lab systems using self-signed RouterOS TLS.
        context.check_hostname = False
        context.verify_mode = ssl.CERT_NONE

        conn = http.client.HTTPSConnection(
            self.host,
            self.port,
            timeout=self.timeout,
            context=context
        )

    else:

        conn = http.client.HTTPConnection(
            self.host,
            self.port,
            timeout=self.timeout
        )

    try:

        conn.request(
            "POST",
            JS_PROXY,
            body=body,
            headers=headers
        )

        response = conn.getresponse()

        status = response.status
        reason = response.reason

        data = response.read()

        return status, reason, data

    finally:

        conn.close()

def __init__(self):

    self.session_id = 0

    self.txseq = 1
    self.rxseq = 1

    self.tx = None
    self.rx = None

    self.private_key = None
    self.public_key = None

# --------------------------------------------------------
# Handshake
# --------------------------------------------------------

def make_initial_request(self):

    self.private_key, self.public_key = generate_keypair()

    # WebFig:
    #
    # word2str(0)
    # word2str(0)
    # pubkey
    #
    # = 8 zero bytes + 32 byte public key

    request = (
        b"\x00" * 8 +
        self.public_key
    )

    if len(request) != 40:
        raise RuntimeError(
            "internal error: handshake is not 40 bytes"
        )

    return request

def process_handshake(self, response):

    if len(response) != 40:

        raise RuntimeError(
            "unexpected /jsproxy handshake response: "
            f"{len(response)} bytes, expected 40"
        )

    # WebFig uses the first four bytes as the session ID.
    self.session_id = int.from_bytes(
        response[0:4],
        "big"
    )

    # Bytes 4..7 are another server-side field.
    field2 = int.from_bytes(
        response[4:8],
        "big"
    )

    # Server public key.
    server_public = response[8:40]

    if len(server_public) != 32:
        raise RuntimeError(
            "server public key is not 32 bytes"
        )

    # Curve25519 shared secret.
    master_key = x25519(
        self.private_key,
        server_public
    )

    rx_key = make_key(
        master_key,
        is_send=False
    )

    tx_key = make_key(
        master_key,
        is_send=True
    )

    self.rx = RouterOSRC4(rx_key)
    self.tx = RouterOSRC4(tx_key)

    return {
        "session_id": self.session_id,
        "field2": field2,
        "server_public": server_public,
        "master_key": master_key,
        "rx_key": rx_key,
        "tx_key": tx_key,
    }

# --------------------------------------------------------
# WebFig framing
# --------------------------------------------------------

def encrypt_frame(self, payload):

    if not isinstance(payload, bytes):
        payload = bytes(payload)

    seq = self.txseq

    # RouterOS WebFig:
    #
    # first 8 bytes:
    #   session ID
    #   sequence
    #
    # remain plaintext.
    header = struct.pack(
        ">II",
        self.session_id,
        seq
    )

    # Encrypt payload with current TX RC4 state.
    encrypted_payload = self.tx.crypt(payload)

    # Then encrypt eight ASCII spaces using the SAME
    # continued RC4 state.
    encrypted_padding = self.tx.crypt(
        b" " * 8
    )

    frame = (
        header +
        encrypted_payload +
        encrypted_padding
    )

    # WebFig increments by payload length + padding length.
    self.txseq += len(payload) + 8

    return frame

# --------------------------------------------------------
# Decrypt response
# --------------------------------------------------------

def decrypt_frame(self, frame):

    if len(frame) < 16:

        raise ValueError(
            "response shorter than minimum WebFig frame"
        )

    session_id = int.from_bytes(
        frame[0:4],
        "big"
    )

    sequence = int.from_bytes(
        frame[4:8],
        "big"
    )

    encrypted_body = frame[8:]

    if len(encrypted_body) < 8:

        raise ValueError(
            "response does not contain 8-byte padding"
        )

    decrypted = self.rx.crypt(
        encrypted_body
    )

    payload = decrypted[:-8]
    padding = decrypted[-8:]

    padding_ok = (
        padding == b" " * 8
    )

    self.rxseq += len(encrypted_body)

    return {
        "session_id": session_id,
        "sequence": sequence,
        "payload": payload,
        "padding": padding,
        "padding_ok": padding_ok,
    }

# msg2buffer({}) starts with:
#
#   4d 32
#
# "M2"
#
# This deliberately contains no:
#   - username
#   - password
#   - token
#   - path
#   - file command
#   - traversal string
#
return b"\x4d\x32"

print()
print("[*] Local protocol self-test")

session = RouterOSSession()

# Synthetic session ID.
session.session_id = 0x12345678

# Deterministic test keys.
tx_key = bytes.fromhex(
    "00112233445566778899aabbccddeeff"
)

rx_key = bytes.fromhex(
    "ffeeddccbbaa99887766554433221100"
)

session.tx = RouterOSRC4(tx_key)
session.rx = RouterOSRC4(rx_key)

payload = b"M2"

frame = session.encrypt_frame(payload)

if frame[:4] != b"\x12\x34\x56\x78":
    raise RuntimeError(
        "local frame session ID test failed"
    )

if frame[4:8] != b"\x00\x00\x00\x01":
    raise RuntimeError(
        "local frame sequence test failed"
    )

if len(frame) != 18:
    raise RuntimeError(
        f"unexpected frame length: {len(frame)}"
    )

print("[+] M2 payload        :", payload.hex())
print("[+] Frame length      :", len(frame))
print("[+] Header            :", frame[:8].hex())
print("[+] Encrypted payload :", frame[8:10].hex())
print("[+] Encrypted padding :", frame[10:].hex())
print("[+] Next TX sequence  :", session.txseq)

print("[+] Local framing test passed")

print("=" * 72)
print(" MikroTik RouterOS /jsproxy Safe CVE Protocol Reproducer")
print("=" * 72)

print(f"Target : {host}:{port}")
print(f"TLS    : {'yes' if ssl_enabled else 'no'}")
print()

# --------------------------------------------------------
# Local protocol validation
# --------------------------------------------------------

try:

    local_frame_test()

except Exception as exc:

    print()
    print("[!] Local protocol self-test failed:")
    print(f"    {exc}")

    return 2

# --------------------------------------------------------
# Create session
# --------------------------------------------------------

session = RouterOSSession()

handshake = session.make_initial_request()

print()
print("[*] Phase 1 - Curve25519 handshake")
print()
print("    Client public key:")
print("    " + hx(session.public_key))

print()
print("    Sending exactly 40 bytes:")
print("    " + handshake.hex())

# --------------------------------------------------------
# Send handshake
# --------------------------------------------------------

transport = JSProxyHTTP(
    host,
    port,
    ssl_enabled=ssl_enabled,
    timeout=timeout
)

started = time.time()

try:

    status, reason, response = transport.request(
        handshake
    )

except (socket.timeout, OSError) as exc:

    print()
    print("[!] Connection failed:")
    print(f"    {exc}")

    return 3

elapsed = time.time() - started

print()
print(f"[+] HTTP status : {status} {reason}")
print(f"[+] Response    : {len(response)} bytes")
print(f"[+] Time        : {elapsed:.3f}s")

if status != 200:

    print()
    print("[!] Handshake HTTP request was not accepted.")

    if response:
        print()
        print("Response:")
        print(hexdump(response[:256]))

    return 4

if len(response) != 40:

    print()
    print(
        "[!] RouterOS did not return the expected "
        "40-byte handshake response."
    )

    print()
    print("Response:")
    print(hexdump(response[:256]))

    return 5

# --------------------------------------------------------
# Process handshake
# --------------------------------------------------------

try:

    info = session.process_handshake(
        response
    )

except Exception as exc:

    print()
    print("[!] Handshake/key derivation failed:")
    print(f"    {exc}")

    return 6

print()
print("[+] Handshake accepted")
print()
print(
    f"    Session ID      : "
    f"0x{info['session_id']:08x}"
)

print(
    f"    Server field    : "
    f"0x{info['field2']:08x}"
)

print(
    "    Server public   : "
    + info["server_public"].hex()
)

print(
    "    Master key      : "
    + info["master_key"].hex()
)

print(
    "    RX key          : "
    + info["rx_key"].hex()
)

print(
    "    TX key          : "
    + info["tx_key"].hex()
)

# --------------------------------------------------------
# Build harmless M2
# --------------------------------------------------------

payload = build_empty_m2()

print()
print("[*] Phase 2 - benign M2 protocol probe")

print()
print("    M2 payload:")
print("    " + hexdump(payload))

print()
print("    Initial sequence:")
print(f"    {session.txseq}")

frame = session.encrypt_frame(
    payload
)

print()
print("    Generated WebFig frame:")
print(hexdump(frame))

print()
print("    Frame breakdown:")
print(
    f"      session ID       = "
    f"0x{session.session_id:08x}"
)

print(
    f"      sequence         = 1"
)

print(
    f"      encrypted data   = "
    f"{frame[8:10].hex()}"
)

print(
    f"      encrypted padding= "
    f"{frame[10:].hex()}"
)

print(
    f"      next TX sequence = "
    f"{session.txseq}"
)

# --------------------------------------------------------
# Send benign M2
# --------------------------------------------------------

print()
print(
    "[*] Sending ONLY the benign M2 frame "
    "(no file/path/auth data)"
)

started = time.time()

try:

    status, reason, response = transport.request(
        frame
    )

except (socket.timeout, OSError) as exc:

    print()
    print("[!] M2 request failed:")
    print(f"    {exc}")

    return 7

elapsed = time.time() - started

print()
print(f"[+] HTTP status : {status} {reason}")
print(f"[+] Response    : {len(response)} bytes")
print(f"[+] Time        : {elapsed:.3f}s")

if not response:

    print()
    print("[*] Server returned an empty response.")
    print()
    print("=" * 72)
    print(" RESULT: handshake verified; no protocol response")
    print("=" * 72)

    return 0

print()
print("[*] Raw response:")
print(hexdump(response[:512]))

# --------------------------------------------------------
# Attempt WebFig response decryption
# --------------------------------------------------------

if status == 200:

    try:

        decoded = session.decrypt_frame(
            response
        )

        print()
        print("[+] WebFig response frame decoded")

        print(
            f"    Session ID : "
            f"0x{decoded['session_id']:08x}"
        )

        print(
            f"    Sequence   : "
            f"{decoded['sequence']}"
        )

        print(
            f"    Padding OK : "
            f"{decoded['padding_ok']}"
        )

        print()
        print("    Decrypted payload:")
        print(
            hexdump(
                decoded["payload"][:512]
            )
        )

    except Exception as exc:

        print()
        print(
            "[!] Response was not decoded as a normal "
            "WebFig encrypted frame:"
        )
        print(f"    {exc}")

# --------------------------------------------------------
# Final result
# --------------------------------------------------------

print()
print("=" * 72)
print(" SAFE CVE PROTOCOL TEST COMPLETE")
print("=" * 72)

print()
print("Verified:")
print("  [+] /jsproxy reachable")
print("  [+] 40-byte Curve25519 handshake")
print("  [+] RouterOS session ID parsing")
print("  [+] WebFig key derivation")
print("  [+] RC4-drop-768 initialization")
print("  [+] WebFig sequence framing")
print("  [+] Encrypted 8-byte padding")
print("  [+] Benign M2 request")

print()
print("Not attempted:")
print("  [-] heap grooming")
print("  [-] heap spraying")
print("  [-] traversal")
print("  [-] arbitrary file reads")
print("  [-] credential extraction")

return 0

if "://" not in value:
    value = "http://" + value

parsed = urlparse(value)

if not parsed.hostname:
    raise ValueError(
        "invalid target"
    )

tls_enabled = (
    parsed.scheme.lower() == "https"
)

if tls_override:
    tls_enabled = True

if port_override is not None:
    port = port_override

elif parsed.port is not None:
    port = parsed.port

else:
    port = 443 if tls_enabled else 80

return (
    parsed.hostname,
    port,
    tls_enabled
)

parser = argparse.ArgumentParser(
    description=(
        "Safe MikroTik RouterOS /jsproxy "
        "CVE protocol reproducer"
    )
)

parser.add_argument(
    "target",
    help=(
        "RouterOS address, e.g. "
        "192.0.2.10 or http://192.0.2.10:8080"
    )
)

parser.add_argument(
    "--port",
    type=int,
    default=None,
    help="override TCP port"
)

parser.add_argument(
    "--https",
    action="store_true",
    help="use HTTPS"
)

parser.add_argument(
    "--timeout",
    type=float,
    default=10.0,
    help="connection timeout in seconds"
)

args = parser.parse_args()

try:

    host, port, tls_enabled = parse_target(
        args.target,
        port_override=args.port,
        tls_override=args.https
    )

except Exception as exc:

    print(
        f"[!] Invalid target: {exc}",
        file=sys.stderr
    )

    return 1

return run_probe(
    host,
    port,
    tls_enabled,
    args.timeout
)