#!/usr/bin/env python3 """paralogue_mitm.py - merged proxy + in-process plaintext decoder. Single-process tool that does three things at once: 1. TCP proxy on 11001 (game server) and 18801 (HTTP dispatch). Redirects traffic from the game to the real servers, logs raw encrypted packets for archival. 2. Frida redirect: rewrites ws2_32!connect() destinations so port 11001 points at 127.0.0.1 (this proxy). 3. Frida plaintext decoder: hooks the game's decrypt/encrypt wrapper at RVA 0x49A2EB0, reassembles [2B prefix][PacketHead][body] framing, identifies each body against the 239-type catalog, and writes structured JSONL with every decoded request/response. Because the plaintext is captured in-process, there is no ChaCha20 key reproduction, no keystream file, and no offset alignment race between wire ciphertext and the in-process cipher state. The proxy and the decoder live in one asyncio event loop. Usage python paralogue_mitm.py python paralogue_mitm.py --no-proxy # decoder only python paralogue_mitm.py --no-decoder # proxy-only forwarding Output captures/mitm__decoded.jsonl decoded messages captures/mitm__wire.jsonl raw wire traffic (ciphertext) captures/mitm__chunks.jsonl raw plaintext chunks from hook """ from __future__ import annotations import argparse import asyncio import json import os import sys import time from typing import Optional import frida SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, SCRIPT_DIR) from paralogue_decoder import ( # noqa: E402 Stream, drain_stream, identify_body, identify_body_strict, msg_to_dict, short_repr, load_known_ids, save_known_ids, CATALOG, PACKET_HEAD_CLS, ) try: from cryptography.hazmat.primitives.ciphers import Cipher, algorithms HAVE_CRYPTO = True except ImportError: HAVE_CRYPTO = False import struct class WireCipher: """ChaCha20 decryptor that tracks a byte-offset counter. IDA analysis of sub_1449A2EB0 (decrypt) and sub_1449A52C0 (encrypt) shows both directions share the key (+0x68) and nonce (+0x78) on the same socket `this`, but maintain independent byte counters at +0x98 (encrypt/C->S) and +0xA0 (decrypt/S->C). So one captured key serves both directions; only the counter differs. ChaCha20 interface: 256-bit key + 128-bit nonce where the first 4B are a little-endian block counter. offset / 64 => block, offset % 64 => skip within the current block. """ def __init__(self, key: bytes, nonce12: bytes, start_offset: int = 0): if not HAVE_CRYPTO: raise RuntimeError("cryptography library required") if len(key) != 32 or len(nonce12) != 12: raise ValueError("key must be 32B, nonce must be 12B") self.key = key self.nonce = nonce12 self.offset = start_offset def decrypt(self, data: bytes) -> bytes: if not data: return b"" block = self.offset // 64 skip = self.offset % 64 full_nonce = struct.pack("Client frame-aware rewriter. Decrypts wire bytes received from the server, splits them into protobuf frames ([2B prefix][head][body]), runs each frame through an optional modify callback, re-encrypts, and returns the new wire bytes to forward to the client. Two independent ChaCha20 ciphers share the key/nonce but track separate byte offsets: * cipher_in — advances by len(server-bytes-received) * cipher_out — advances by len(client-bytes-forwarded) When the modify callback returns the same bytes, in and out stay in lockstep and the emitted wire ciphertext is byte-identical to the input (since ChaCha20 XOR is an involution). When modify changes a frame's size the two diverge, but the client's own decrypt counter tracks proxy-sent bytes so it stays in sync with cipher_out. The first S->C packet is a hybrid: 2B-prefix plaintext handshake (`VerifyLoginTokenRsp`, msg_id 1002) optionally followed by an encrypted tail that is the first post-handshake frame. The plaintext handshake is passed through untouched; only the tail feeds the ciphers. """ def __init__(self, modify_cb=None, label: str = "S->C"): self.label = label self.cipher_in: Optional[WireCipher] = None self.cipher_out: Optional[WireCipher] = None self.pre_enc_buf = bytearray() self.handshake_done = False # Encrypted bytes forwarded before the key arrived. Client will # have processed them at its own counter; once the key arrives # we initialize our ciphers at the corresponding offset so we # don't re-decrypt those already-sent bytes. self.passthrough_enc_bytes = 0 self.plain_buf = bytearray() # decrypted plaintext, awaiting framing self.modify_cb = modify_cb self.frames_seen = 0 self.frames_modified = 0 def set_key(self, key: bytes, nonce: bytes) -> None: if self.cipher_in is not None: return # Both ciphers start AFTER any bytes we forwarded unchanged before # the key was available. Client's own decrypt counter == bytes # received since handshake == passthrough_enc_bytes. off = self.passthrough_enc_bytes self.cipher_in = WireCipher(key, nonce, off) self.cipher_out = WireCipher(key, nonce, off) def process(self, data: bytes) -> bytes: if not self.handshake_done: return self._handshake_phase(data) # Post-handshake: decrypt, buffer plaintext, drain complete frames, # re-encrypt and return. if self.cipher_in is None: # Key still not captured (client hasn't processed first decrypt # yet). Forward bytes untouched so the client can make # progress; count them so the eventual cipher start offset # reflects what's already on the wire. self.passthrough_enc_bytes += len(data) return data plain = self.cipher_in.decrypt(data) self.plain_buf.extend(plain) return self._drain_and_encrypt() # ---- internal helpers ---- def _drain_and_encrypt(self) -> bytes: from paralogue_decoder import PACKET_HEAD_CLS out_plain = bytearray() while True: if len(self.plain_buf) < 2: break hlen = (self.plain_buf[0] << 8) | self.plain_buf[1] if hlen == 0 or hlen > 32: # Invalid framing — forward rest as-is and bail. Shouldn't # happen in a healthy stream. out_plain.extend(self.plain_buf) self.plain_buf = bytearray() break if len(self.plain_buf) < 2 + hlen: break try: head = PACKET_HEAD_CLS() head.MergeFromString(bytes(self.plain_buf[2:2 + hlen])) body_len = int(head.body_len) except Exception: break total = 2 + hlen + body_len if len(self.plain_buf) < total: break frame = bytes(self.plain_buf[:total]) del self.plain_buf[:total] self.frames_seen += 1 out_frame = self._maybe_modify(frame, head) if out_frame is not frame: self.frames_modified += 1 out_plain.extend(out_frame) if self.cipher_out is None: # Shouldn't happen (cipher_in implies cipher_out), but be safe. return bytes(out_plain) return self.cipher_out.encrypt(bytes(out_plain)) def _maybe_modify(self, frame: bytes, head) -> bytes: if self.modify_cb is None: return frame hlen = (frame[0] << 8) | frame[1] body = frame[2 + hlen:] new_body = self.modify_cb(int(head.msg_id), head, body) if new_body is None or new_body is body: return frame # Update head.body_len to reflect the new body size and re-emit. head.body_len = len(new_body) new_head = head.SerializeToString() new_hlen = len(new_head) return bytes([(new_hlen >> 8) & 0xFF, new_hlen & 0xFF]) + new_head + new_body def _handshake_phase(self, data: bytes) -> bytes: from paralogue_decoder import PACKET_HEAD_CLS self.pre_enc_buf.extend(data) if len(self.pre_enc_buf) < 2: return b"" hlen = (self.pre_enc_buf[0] << 8) | self.pre_enc_buf[1] if hlen == 0 or hlen > 32: return b"" # keep buffering if len(self.pre_enc_buf) < 2 + hlen: return b"" try: head = PACKET_HEAD_CLS() head.MergeFromString(bytes(self.pre_enc_buf[2:2 + hlen])) body_len = int(head.body_len) except Exception: return b"" frame_end = 2 + hlen + body_len if len(self.pre_enc_buf) < frame_end: return b"" handshake = bytes(self.pre_enc_buf[:frame_end]) tail = bytes(self.pre_enc_buf[frame_end:]) self.pre_enc_buf = bytearray() self.handshake_done = True out = bytearray(handshake) if tail: if self.cipher_in is None: # Forward the encrypted tail untouched. Client needs it # to finish key setup (the tail IS the first encrypted # frame that triggers the decrypt call where Frida reads # the key). Count it so cipher offsets start after these # bytes once the key arrives. self.passthrough_enc_bytes += len(tail) out.extend(tail) else: plain = self.cipher_in.decrypt(tail) self.plain_buf.extend(plain) out.extend(self._drain_and_encrypt()) return bytes(out) def expand_card_bag_open_rsp_modifier(msg_id: int, head, body: bytes): """modify_cb: when the server sends a CardBagOpenRsp (msg_id=1193) in response to a blueprint open, expand `rets` to include every card_id 0..1000. The client appends each returned card_id to its local learn_cards collection, so the Experiment UI count jumps by however many valid card_ids are in that range. Invalid ones are silently dropped by the client's DataTable filter.""" if msg_id != 1193: return None import paralogue_net_full_pb2 as pb try: msg = pb.CardBagOpenRsp() msg.MergeFromString(body) except Exception: return None # Preserve pack_guarantee/total_guarantee from the real response; # just replace rets with a full 0..1000 array. del msg.rets[:] for cid in range(0, 2001): r = msg.rets.add() r.card_id = cid msg.status = 1 try: out = msg.SerializeToString() except Exception: return None print(f" [inject] CardBagOpenRsp: rets=0..2000 ({len(msg.rets)} cards) " f"(body {len(body)}B -> {len(out)}B)") return out def inject_blueprints_modifier(msg_id: int, head, body: bytes): """modify_cb: when BagItemFullS2C (msg_id=1036) passes through, inject blueprint items in the 11000..11999 range. Blueprints are lootbox-style Pack items that can be opened via CardBagOpenReq to grant experiment cards. Client filters against its local ItemTable so only valid blueprint IDs actually display.""" if msg_id != 1036: return None import paralogue_net_full_pb2 as pb try: msg = pb.BagItemFullS2C() msg.MergeFromString(body) except Exception: return None existing = {it.itemId for it in msg.items} added = 0 for iid in range(11000, 12000): if iid in existing: continue it = msg.items.add() it.itemId = iid it.num = 1 added += 1 try: out = msg.SerializeToString() except Exception: return None print(f" [inject] BagItemFullS2C: +{added} blueprints (11xxx) " f"(body {len(body)}B -> {len(out)}B)") return out def inject_unlock_functions_modifier(msg_id: int, head, body: bytes): """modify_cb: for PlayerMainDataRsp (msg_id=1006), populate unlockFunctions with every uint32 from 1..2000. If experiments are gated by feature IDs in this list, every experiment should unlock.""" if msg_id != 1006: return None import paralogue_net_full_pb2 as pb try: msg = pb.PlayerMainDataRsp() msg.MergeFromString(body) except Exception: return None for fid in range(1, 2001): msg.unlockFunctions.append(fid) try: out = msg.SerializeToString() except Exception: return None print(f" [inject] PlayerMainDataRsp: unlockFunctions=1..2000 " f"(body {len(body)}B -> {len(out)}B)") return out def inject_role_attrs_modifier(msg_id: int, head, body: bytes): """modify_cb: for RoleListFullS2C (msg_id=1202), mark every role as unlocked and saturate every attrs entry to a high value. If the per-role attrs map is the actual 'experiments' storage, the UI should display every experiment as complete after this rewrites the login push.""" if msg_id != 1202: return None import paralogue_net_full_pb2 as pb try: msg = pb.RoleListFullS2C() msg.MergeFromString(body) except Exception: return None touched_roles = 0 touched_attrs = 0 for role in msg.role_list.roles: role.is_unlock = True for k in list(role.attrs.keys()): role.attrs[k] = 999 touched_attrs += 1 # Saturate related dilation/favor/stamina fields too, in case # "experiments" is gated by these rather than the attrs map. role.favor_lv = 99 role.vaginal_dilation_lv = 99 role.anal_dilation_lv = 99 touched_roles += 1 try: out = msg.SerializeToString() except Exception: return None print(f" [inject] RoleListFullS2C: {touched_roles} roles unlocked, " f"{touched_attrs} attrs saturated (body {len(body)}B -> {len(out)}B)") return out def inject_items_1_to_2000_modifier(msg_id: int, head, body: bytes): """modify_cb: when a BagItemFullS2C (msg_id=1036) passes through, densely fill every observed ID range so we can see which tab each prefix maps to. The client's ItemTable silently drops invalid IDs, so spraying a range only reveals items the game defines. Observed ranges in real traffic: 0xxxx (2..574) -> likely Gift 1xxxx (11001..11042) -> Pack 2xxxx (20005..28007) -> Card or Normal 3xxxx (31013..31442) -> Cloth (confirmed) 4xxxx (40001..40022) -> Normal (experiments?) 9xxxx (99981..99999) -> Money/Title 100001 -> singleton """ if msg_id != 1036: return None import paralogue_net_full_pb2 as pb try: msg = pb.BagItemFullS2C() msg.MergeFromString(body) except Exception: return None # Build candidate IDs: dense across each observed range. # NOTE: blueprints (11xxx) deliberately excluded — sending a # CardBagOpenReq with a forged id to the server would trigger # status=13 rejections at best and may flag the account, so # we don't want fake blueprints polluting the bag at all. candidates = set() candidates.update(range(1, 1000)) # 0xxxx low candidates.update(range(20000, 29000)) # 2xxxx card/normal candidates.update(range(31000, 32000)) # 3xxxx cloth candidates.update(range(40000, 41000)) # 4xxxx experiments? candidates.update(range(99900, 100100)) # 99xxx money candidates.update(range(100000, 100100)) # singleton neighborhood existing = {it.itemId for it in msg.items} added = 0 for iid in sorted(candidates): if iid in existing: continue it = msg.items.add() it.itemId = iid it.num = 1 added += 1 # Diagnostic: bump the count of a known currency item. If the UI # reflects this, the client is honoring our rewritten packet and # the missing injected items are being filtered by the client-side # ItemTable (they need to exist in the data asset). If the UI # ignores this bump too, the client is reading bag state from # somewhere other than BagItemFullS2C. TARGET_BUMP_ID = 99991 TARGET_BUMP_NUM = 999999 bumped = False for it in msg.items: if it.itemId == TARGET_BUMP_ID: it.num = TARGET_BUMP_NUM bumped = True break try: out = msg.SerializeToString() except Exception: return None print(f" [inject] BagItemFullS2C: +{added} items, " f"bump[{TARGET_BUMP_ID}]->{TARGET_BUMP_NUM}={bumped} " f"(body {len(body)}B -> {len(out)}B)") return out PROCESS_NAME = "Paralogue-Win64-Shipping.exe" DECODER_JS = os.path.join(SCRIPT_DIR, "protocol_decoder.js") REDIRECT_JS = os.path.join(SCRIPT_DIR, "redirect_connect.js") DISPATCH_JS = os.path.join(SCRIPT_DIR, "dispatch_dump.js") ITEM_DUMP_JS = os.path.join(SCRIPT_DIR, "item_table_dump.js") OUT_DIR = os.path.join(SCRIPT_DIR, "captures") os.makedirs(OUT_DIR, exist_ok=True) GAME_SERVER_IP = "3.33.185.193" DISPATCH_IP = "13.248.150.146" GAME_PORT = 11001 HTTP_PORT = 18801 REAL_SERVER_IPS = [ "13.248.150.146", "35.71.128.233", "3.33.185.193", "76.223.57.31", ] def _name_direction_mismatch(name: str, direction: str) -> bool: """True if a protobuf type name's suffix contradicts the wire direction. E.g. 'KickPlayerS2C' on a C->S packet, or 'PlayerPingReq' on S->C.""" if direction == "C->S": if name.endswith("S2C") or name.endswith("Rsp"): return True elif direction == "S->C": if name.endswith("C2S") or name.endswith("Req"): return True return False # --------------------------------------------------------------------------- # session state # --------------------------------------------------------------------------- class Session: STRONG_SCORE = 60 def __init__(self, ts: int): self.decoded_path = os.path.join(OUT_DIR, f"mitm_{ts}_decoded.jsonl") self.wire_path = os.path.join(OUT_DIR, f"mitm_{ts}_wire.jsonl") self.chunks_path = os.path.join(OUT_DIR, f"mitm_{ts}_chunks.jsonl") self.dispatch_path = os.path.join(OUT_DIR, f"mitm_{ts}_dispatch.jsonl") self._decoded_fp = open(self.decoded_path, "w", encoding="utf-8") self._wire_fp = open(self.wire_path, "w", encoding="utf-8") self._chunks_fp = open(self.chunks_path, "w", encoding="utf-8") self._dispatch_fp = open(self.dispatch_path, "w", encoding="utf-8") # msg_id -> factory_rva (module-relative, stable across runs under ASLR). self.msg_id_to_factory: dict[int, str] = {} # factory_rva -> type_name once resolved by strict identification. # Persisted: factories are stable across runs because the exe is # built without /DYNAMICBASE (module_base == 0x140000000 always). self.factory_to_type: dict[str, str] = {} self._factory_map_path = os.path.join(SCRIPT_DIR, "factory_to_type.json") if os.path.isfile(self._factory_map_path): try: with open(self._factory_map_path, "r", encoding="utf-8") as f: self.factory_to_type = json.load(f) except Exception: self.factory_to_type = {} self.streams: dict[tuple[str, int], Stream] = {} self.msg_id_cache = load_known_ids() self._user_ids = set(self.msg_id_cache.keys()) self.decoded_seq = 0 self.wire_seq = 0 self.chunk_seq = 0 self._send_offset = 0 # Cryptography experiment: if Frida provides the key/nonce, try # decrypting wire ciphertext ourselves using OpenSSL's ChaCha20. # Success proves we can do Frida-free decoding on the proxy side. self.session_key: Optional[bytes] = None self.session_nonce: Optional[bytes] = None self.session_offset_at_capture: int = 0 self._captured_plaintext_at_offset: dict[int, bytes] = {} self._verify_pending: list[tuple[int, bytes]] = [] # Per-direction wire decryption state. Initialized on first key # capture. Wire bytes are fed through these to recover plaintext # without needing the Frida plaintext hook. self.wire_cipher_c2s: Optional[WireCipher] = None self.wire_cipher_s2c: Optional[WireCipher] = None # Proxy-observed wire bytes per direction since the connection # started. On key capture we snapshot these to align counters. self.wire_bytes_c2s: int = 0 self.wire_bytes_s2c: int = 0 self.wire_streams: dict[str, Stream] = { "C->S": Stream(label="wire-C->S"), "S->C": Stream(label="wire-S->C"), } # Pre-encryption state. The RSA handshake frame (msg_id 1001 C->S # / 1002 S->C) is sent as plaintext BEFORE ChaCha20 kicks in. The # packet that carries the S->C handshake response may also carry # the first encrypted frame in its tail. We buffer each direction # and parse exactly one plaintext frame; anything after it feeds # the WireCipher at offset 0. self._pre_enc_buf: dict[str, bytearray] = {"C->S": bytearray(), "S->C": bytearray()} self._handshake_done: dict[str, bool] = {"C->S": False, "S->C": False} # S->C rewriter: sits on the proxy's forwarding path and can # rewrite frames before they reach the client. self.s2c_rewriter: Optional[WireRewriter] = None # C->S rewriter: same but for client->server direction. Needed # for C->S packet injection (without it, injecting breaks the # server's decrypt counter). In identity mode (no modify_cb), # output == input due to ChaCha20 XOR involution. self.c2s_rewriter: Optional[WireRewriter] = None # Bytes seen post-handshake but before the Frida key capture # arrived (async timing). Flushed through the cipher in # record_session_key. self._wire_pending: dict[str, bytearray] = {"C->S": bytearray(), "S->C": bytearray()} # Writer refs for packet injection. Set per TCP connection in # handle_game_client(), cleared on disconnect. self.client_writer: Optional[asyncio.StreamWriter] = None self.server_writer: Optional[asyncio.StreamWriter] = None # C->S injection cipher — separate from the wire-decryption # cipher. Tracks the server's expected decrypt counter so # injected C->S frames are decryptable. Initialized alongside # other ciphers in record_session_key(). self.c2s_inject_cipher: Optional[WireCipher] = None self.c2s_bytes_sent: int = 0 # total encrypted C->S bytes forwarded # Auto-incrementing packet_id for injected frames. self._inject_packet_id: int = 60000 # Write locks to prevent interleaved writes from pipe() and # the injection consumer. One per direction. self.s2c_write_lock: asyncio.Lock = asyncio.Lock() self.c2s_write_lock: asyncio.Lock = asyncio.Lock() def close(self) -> None: for fp in (self._decoded_fp, self._wire_fp, self._chunks_fp, self._dispatch_fp): try: fp.close() except Exception: pass def record_dispatch_entry(self, msg_id: int, vtbl: str, factory_abs: str) -> None: # Key by vtable address (stable .rdata, unlike heap-allocated # factory object). vtbl == class identifier across runs. self.msg_id_to_factory[msg_id] = vtbl self._dispatch_fp.write(json.dumps({ "msg_id": msg_id, "vtbl": vtbl, "factory_abs": factory_abs, }) + "\n") self._dispatch_fp.flush() # ---- key capture -------------------------------------------------- def record_session_key(self, key: bytes, nonce: bytes, offset: int, flag: int = 0, this_id: str = "", offset_enc: int = 0, offset_dec: int = 0) -> None: # The game pools cipher contexts across reconnects; a single # this_id can host multiple keys over time. Key by (this_id, key). if not hasattr(self, "keys_by_ctx"): self.keys_by_ctx: dict[tuple[str, str], dict] = {} ck = (this_id, key.hex()) if ck in self.keys_by_ctx: return self.keys_by_ctx[ck] = { "key": key, "nonce": nonce, "offset_at_capture": offset, "flag": flag, "this_id": this_id, } if self.session_key is None: self.session_key = key self.session_nonce = nonce self.session_offset_at_capture = offset # Initialize per-direction wire decryptors. The game's counter # at capture time reflects how many post-handshake bytes have # already flowed; proxy aligns by assuming its observed wire # bytes so far for that direction == game counter at capture. if HAVE_CRYPTO and len(nonce) == 12: try: self.wire_cipher_c2s = WireCipher(key, nonce, offset_enc) self.wire_cipher_s2c = WireCipher(key, nonce, offset_dec) self._wire_c2s_snapshot = self.wire_bytes_c2s self._wire_s2c_snapshot = self.wire_bytes_s2c if self.s2c_rewriter is not None: self.s2c_rewriter.set_key(key, nonce) if self.c2s_rewriter is not None: self.c2s_rewriter.set_key(key, nonce) except Exception as e: print(f"[!] wire cipher init failed: {e}") print(f"\n{'='*64}\n SESSION KEY captured (ctx={this_id} flag={flag})\n" f" key = {key.hex()}\n" f" nonce = {nonce.hex()}\n" f" game counters: enc(C->S)={offset_enc} dec(S->C)={offset_dec}\n" f" proxy wire: C->S={self.wire_bytes_c2s} S->C={self.wire_bytes_s2c}\n" f" pending bytes: C->S={len(self._wire_pending['C->S'])} " f"S->C={len(self._wire_pending['S->C'])}\n" f"{'='*64}\n") for d in ("C->S", "S->C"): pending = bytes(self._wire_pending[d]) self._wire_pending[d] = bytearray() if pending: self._feed_cipher(d, pending) try: with open(os.path.join(OUT_DIR, "current_session_key.json"), "w") as f: json.dump({ "contexts": [ { "this_id": v["this_id"], "flag": v["flag"], "offset_at_capture": v["offset_at_capture"], "key_hex": v["key"].hex(), "nonce_hex": v["nonce"].hex(), } for v in self.keys_by_ctx.values() ], "ts": time.time(), }, f, indent=2) except Exception: pass def _try_verify_library(self) -> None: """Sanity-check the cryptography-library ChaCha20 against a known plaintext+ciphertext pair, IF we have any samples logged. The current merged tool only captures plaintext, not ciphertext, so this prints the library's keystream at offset 0 for manual comparison against a captured wire packet. """ if not HAVE_CRYPTO or self.session_key is None: return import struct full_nonce = struct.pack(" None: self.wire_seq += 1 rec = { "n": self.wire_seq, "ts": time.time(), "d": direction, "sz": len(data), "hex": data.hex(), "label": label, } self._wire_fp.write(json.dumps(rec) + "\n") self._wire_fp.flush() arrow = ">>>" if direction == "C->S" else "<<<" extra = f" {label}" if label else "" print(f"[wire #{self.wire_seq:04d}] {arrow} {direction} {len(data):5d}B{extra}") if direction == "C->S": self.wire_bytes_c2s += len(data) cipher = self.wire_cipher_c2s else: self.wire_bytes_s2c += len(data) cipher = self.wire_cipher_s2c # Phase 1: consume the plaintext handshake frame (msg_id 1001/1002). if not self._handshake_done[direction]: buf = self._pre_enc_buf[direction] buf.extend(data) # Need at least 2B for prefix length. if len(buf) < 2: return prefix = int.from_bytes(buf[:2], "big") if len(buf) < 2 + prefix: return # Parse head to get body_len. try: from paralogue_decoder import PACKET_HEAD_CLS head = PACKET_HEAD_CLS() head.ParseFromString(bytes(buf[2:2 + prefix])) body_len = int(head.body_len) except Exception: return frame_end = 2 + prefix + body_len if len(buf) < frame_end: return handshake_body = bytes(buf[2 + prefix:frame_end]) self._emit_decoded(direction, 0, head, handshake_body, source="wire") leftover = bytes(buf[frame_end:]) self._handshake_done[direction] = True self._pre_enc_buf[direction] = bytearray() data = leftover # fall through to cipher path with the tail if not data: return if cipher is None: # Key not captured yet (async). Stash and drain later. self._wire_pending[direction].extend(data) return self._feed_cipher(direction, bytes(data)) def _feed_cipher(self, direction: str, data: bytes) -> None: cipher = (self.wire_cipher_c2s if direction == "C->S" else self.wire_cipher_s2c) if cipher is None or not data: return try: plain = cipher.decrypt(data) except Exception as e: print(f"[!] wire decrypt failed ({direction}): {e}") return stream = self.wire_streams[direction] stream.add(stream.frontier, plain) for head, body, _skipped in drain_stream(stream): self._emit_decoded(direction, stream.consumed, head, body, source="wire") # ---- chunks (plaintext from Frida hook) --------------------------- def log_chunk(self, meta: dict, data: bytes) -> None: self.chunk_seq += 1 this_id = meta["this_id"] source = meta.get("source", "recv") # recv path = decrypt wrapper = S->C plaintext (post-decrypt) # send path = pre-send helper = C->S plaintext (pre-encrypt) if source == "send": direction = "C->S" enc = 1 off = self._send_offset self._send_offset += len(data) else: direction = "S->C" enc = 0 off = int(meta.get("off", 0)) rec = { "n": self.chunk_seq, "dir": direction, "off": off, "len": len(data), "hex": data.hex(), } self._chunks_fp.write(json.dumps(rec) + "\n") self._chunks_fp.flush() key = (this_id, enc) stream = self.streams.get(key) if stream is None: stream = Stream(label=direction) self.streams[key] = stream stream.add(off, data) for head, body, _skipped in drain_stream(stream): self._emit_decoded(direction, off, head, body) # ---- decoded ------------------------------------------------------- def _emit_decoded(self, direction: str, off: int, head, body: bytes, source: str = "frida") -> None: mid = int(head.msg_id) # Preferred order for this msg_id: # 1. factory-pinned name (ground truth from dispatch table + one # confident strict-parse earlier in the session) # 2. user-provided known_msg_ids.json entry # 3. legacy cache (heuristic-learned) factory = self.msg_id_to_factory.get(mid) preferred = None if factory and factory in self.factory_to_type: preferred = self.factory_to_type[factory] if preferred is None: preferred = self.msg_id_cache.get(mid) # Don't feed a wrong-direction name as a hint — it biases # identify_body into picking a type that contradicts the wire. if preferred and _name_direction_mismatch(preferred, direction): preferred = None strict = identify_body_strict(body) if body else [] strict_names = [s[0] for s in strict] # If multiple strict candidates, apply a direction-aware # naming preference so we can still pin confidently: inbound # (S->C) messages are typically named *S2C, outbound (C->S) # are *C2S/*Req. If exactly one candidate matches the expected # suffix pattern, treat that as the unambiguous choice. if len(strict_names) > 1: if direction == "S->C": suffixed = [n for n in strict_names if n.endswith("S2C")] else: suffixed = [n for n in strict_names if n.endswith("C2S") or n.endswith("Req")] if len(suffixed) == 1: strict_names = suffixed strict = [s for s in strict if s[0] == suffixed[0]] # Pin factory -> type when strict identification is unambiguous. if (factory and factory not in self.factory_to_type and len(strict_names) == 1): pinned = strict_names[0] self.factory_to_type[factory] = pinned self.msg_id_cache[mid] = pinned # Strict ID trumps any prior heuristic cache entry. save_known_ids(self.msg_id_cache) try: with open(self._factory_map_path, "w", encoding="utf-8") as f: json.dump(self.factory_to_type, f, indent=2, sort_keys=True) except Exception: pass print(f" [pinned] msg_id={mid} factory={factory} -> {pinned}") name, parsed, score, cand, top = identify_body(body, preferred) # If the strict set is non-empty, override the heuristic pick: # prefer the strict candidate that matches `preferred` or the # first strict candidate otherwise. if strict and (preferred in strict_names or name not in strict_names): pick = preferred if preferred in strict_names else strict_names[0] for sn, sm, _exact in strict: if sn == pick: name, parsed = sn, sm score = max(score, 200) break # Final direction sanity: reject names whose suffix contradicts # the actual wire direction (e.g. *S2C on a C->S packet). if name and _name_direction_mismatch(name, direction): # Purge the stale entry from in-memory cache so it never # gets re-saved to known_msg_ids.json via a different path. if mid in self.msg_id_cache and self.msg_id_cache[mid] == name: del self.msg_id_cache[mid] save_known_ids(self.msg_id_cache) # Try to find a direction-compatible alternative from strict. replacement = None for sn, sm, _ in strict: if not _name_direction_mismatch(sn, direction): replacement = (sn, sm) break if replacement: name, parsed = replacement score = max(score, 200) else: name = None parsed = None score = 0 if name and not preferred and score >= self.STRONG_SCORE: self.msg_id_cache[mid] = name if mid not in self._user_ids: save_known_ids(self.msg_id_cache) if parsed is not None: fields_obj = msg_to_dict(parsed) parsed_ok = True else: fields_obj = None parsed_ok = False try: head_hex = head.SerializeToString().hex() except Exception: head_hex = "" self.decoded_seq += 1 record = { "seq": self.decoded_seq, "ts": time.time(), "source": source, "direction": direction, "stream_offset": off, "msg_id": mid, "msg_type": name or "", "packet_id": int(head.packet_id), "flag": int(head.flag), "body_len": int(head.body_len), "seq_id": int(head.seq_id), "total_pack_count": int(head.total_pack_count), "identify_score": score, "identify_candidates": cand, "strict_candidates": strict_names, "factory_rva": factory, "top_candidates": [{"type": n, "score": s} for n, s in top], "parsed": parsed_ok, "fields": fields_obj, "head_hex": head_hex, "body_hex": body.hex(), } self._decoded_fp.write(json.dumps(record, ensure_ascii=False) + "\n") self._decoded_fp.flush() tag = "W" if source == "wire" else "F" summary = short_repr(fields_obj) if parsed_ok else f"_raw={body[:24].hex()}" print( f"[dec #{self.decoded_seq:04d}] [{tag}] {direction} " f"msg_id={mid:<5d} {record['msg_type']:<28s} " f"body={record['body_len']:>5d}B {summary}" ) # --------------------------------------------------------------------------- # asyncio proxy # --------------------------------------------------------------------------- def build_frame(msg_id: int, body: bytes, packet_id: int = 0, seq_id: int = 0, flag: int = 0) -> bytes: """Build a wire frame: [2B prefix][PacketHead][body].""" head = PACKET_HEAD_CLS() head.msg_id = msg_id head.body_len = len(body) head.packet_id = packet_id head.seq_id = seq_id head.flag = flag head_bytes = head.SerializeToString() prefix = len(head_bytes).to_bytes(2, "big") return prefix + head_bytes + body async def pipe(reader, writer, session: Session, direction: str) -> None: lock = (session.s2c_write_lock if direction == "S->C" else session.c2s_write_lock) try: while True: data = await reader.read(65536) if not data: break session.log_wire(direction, data) async with lock: if direction == "S->C" and session.s2c_rewriter is not None: out = session.s2c_rewriter.process(data) if out: writer.write(out) await writer.drain() elif direction == "C->S" and session.c2s_rewriter is not None: out = session.c2s_rewriter.process(data) if out: writer.write(out) await writer.drain() else: writer.write(data) await writer.drain() except (ConnectionResetError, BrokenPipeError, asyncio.CancelledError): pass finally: try: writer.close() except Exception: pass async def handle_game_client(reader, writer, session: Session) -> None: addr = writer.get_extra_info("peername") print(f"[+] game client {addr}") # Reset the rewriter for the new TCP connection: each game login # begins with a fresh RSA handshake and a new ChaCha20 key, so # handshake state + counters must start from zero. if session.s2c_rewriter is not None: cb = session.s2c_rewriter.modify_cb session.s2c_rewriter = WireRewriter(modify_cb=cb, label="S->C") print("[*] s2c_rewriter reset for new connection") if session.c2s_rewriter is not None: cb = session.c2s_rewriter.modify_cb session.c2s_rewriter = WireRewriter(modify_cb=cb, label="C->S") print("[*] c2s_rewriter reset for new connection") session.c2s_bytes_sent = 0 try: sr, sw = await asyncio.open_connection(GAME_SERVER_IP, GAME_PORT) except Exception as e: print(f"[!] cannot reach real server: {e}") writer.close() return # Store writer refs for packet injection. session.client_writer = writer session.server_writer = sw try: await asyncio.gather( pipe(reader, sw, session, "C->S"), pipe(sr, writer, session, "S->C"), return_exceptions=True, ) finally: session.client_writer = None session.server_writer = None print(f"[-] game client {addr} disconnected") async def handle_http_client(reader, writer, session: Session) -> None: addr = writer.get_extra_info("peername") print(f"[+] http client {addr}") try: sr, sw = await asyncio.open_connection(DISPATCH_IP, HTTP_PORT) except Exception as e: print(f"[!] cannot reach http: {e}") writer.close() return async def c2s(r, w): try: while True: d = await r.read(65536) if not d: break try: first = d.split(b"\r\n", 1)[0].decode(errors="replace") print(f" [HTTP C->S] {first}") except Exception: pass w.write(d) await w.drain() except Exception: pass async def s2c(r, w): try: while True: d = await r.read(65536) if not d: break for ip in REAL_SERVER_IPS: if ip.encode() in d: pad = b" " * (len(ip) - len("127.0.0.1")) d = d.replace(ip.encode(), b"127.0.0.1" + pad) w.write(d) await w.drain() except Exception: pass await asyncio.gather(c2s(reader, sw), s2c(sr, writer), return_exceptions=True) print(f"[-] http client {addr} disconnected") # --------------------------------------------------------------------------- # Frida bridge # --------------------------------------------------------------------------- class FridaBridge: """Attaches Frida scripts and forwards messages to the asyncio session. Frida fires `on_message` on its own thread; we marshal into the main asyncio loop via `loop.call_soon_threadsafe` so the Session's file I/O stays single-threaded. """ def __init__(self, session: Session, loop: asyncio.AbstractEventLoop, with_redirect: bool = True): self.session = session self.loop = loop self.with_redirect = with_redirect self.frida_session = None self.scripts: list = [] async def start(self) -> None: with open(DECODER_JS, "r", encoding="utf-8") as f: decoder_src = f.read() redirect_src = None if self.with_redirect: with open(REDIRECT_JS, "r", encoding="utf-8") as f: redirect_src = f.read() print(f"[*] waiting for {PROCESS_NAME} ...") while self.frida_session is None: try: for proc in frida.get_local_device().enumerate_processes(): if proc.name == PROCESS_NAME: print(f"[*] attaching to PID {proc.pid}") self.frida_session = frida.attach(proc.pid) break except Exception as e: print(f"[!] {e}") if self.frida_session is None: await asyncio.sleep(1) if redirect_src: r = self.frida_session.create_script(redirect_src) r.on("message", self._redirect_msg) r.load() self.scripts.append(r) print("[*] redirect hook loaded") d = self.frida_session.create_script(decoder_src) d.on("message", self._decoder_msg) d.load() self.scripts.append(d) print("[*] decoder hook loaded") try: with open(DISPATCH_JS, "r", encoding="utf-8") as f: dispatch_src = f.read() dp = self.frida_session.create_script(dispatch_src) dp.on("message", self._dispatch_msg) dp.load() self.scripts.append(dp) print("[*] dispatch hook loaded") except FileNotFoundError: print("[!] dispatch_dump.js missing; skipping table walk") try: with open(ITEM_DUMP_JS, "r", encoding="utf-8") as f: idsrc = f.read() ip = self.frida_session.create_script(idsrc) ip.on("message", self._item_dump_msg) ip.load() self.scripts.append(ip) print("[*] item_table_dump hook loaded") except FileNotFoundError: pass def stop(self) -> None: for s in self.scripts: try: s.unload() except Exception: pass if self.frida_session: try: self.frida_session.detach() except Exception: pass def _item_dump_msg(self, message, data): if message.get("type") == "error": print(f"[!] item_dump js: {message.get('description','')}") return p = message.get("payload") or {} t = p.get("t") if t == "ready": print(f"[*] {p.get('msg','')}") elif t == "item_subsystem": print(f"[*] item subsystem pointer: {p.get('addr')}") self._item_ids = [] elif t == "item_block": print(f" item block @ {p.get('ptr')} count={p.get('count')}") elif t == "item_id": if not hasattr(self, "_item_ids"): self._item_ids = [] self._item_ids.append(int(p["id"])) elif t == "item_dump_done": ids = sorted(set(getattr(self, "_item_ids", []))) path = os.path.join(SCRIPT_DIR, "client_item_ids.json") with open(path, "w", encoding="utf-8") as f: json.dump(ids, f) print(f"[*] item dump: {len(ids)} unique ids -> {path}") # summarize by prefix from collections import Counter buckets = Counter(iid // 1000 for iid in ids) print(" prefix histogram (id//1000): " + " ".join(f"{k}x:{v}" for k, v in sorted(buckets.items()))) def _dispatch_msg(self, message, data): if message.get("type") == "error": print(f"[!] dispatch js: {message.get('description','')}") return p = message.get("payload") or {} t = p.get("t") if t == "dispatch_info": print(f"[*] dispatch table: used={p.get('used')} " f"size={p.get('hash_size')} inline={p.get('inline')}") print(f"[*] module_base={p.get('module_base')} " f"module_size={hex(p.get('module_size', 0))} " f"buckets={p.get('buckets')}") elif t == "dispatch_entry": # Log the first few entries fully to diagnose struct layout. if self.session.msg_id_to_factory == {} or len( self.session.msg_id_to_factory) < 3: raw = data.hex() if data else "" print(f" dispatch msg_id={p.get('msg_id')} " f"factory={p.get('factory')} vtbl={p.get('vtbl')} " f"first_vtbl_entry={p.get('first_vtbl_entry')} " f"raw={raw}") self.loop.call_soon_threadsafe( self.session.record_dispatch_entry, int(p["msg_id"]), p.get("vtbl", ""), p.get("factory", ""), ) elif t == "dispatch_done": print(f"[*] dispatch table walk complete: {p.get('total')} entries") elif t == "error": print(f"[!] dispatch: {p.get('msg','')}") def _redirect_msg(self, message, data): if message.get("type") == "error": print(f"[!] redirect js: {message.get('description','')}") return p = message.get("payload") or {} t = p.get("t") if t == "ready": print(f"[*] redirect: {p.get('msg','')}") elif t == "redirect": print(f"[*] redirect: {p.get('from')}:{p.get('port')} -> {p.get('to')}") def _decoder_msg(self, message, data): if message.get("type") == "error": print(f"[!] decoder js: {message.get('description','')}") return p = message.get("payload") or {} t = p.get("t") if t == "ready": print(f"[*] decoder: {p.get('msg','')}") elif t == "chunk" and data is not None: chunk = bytes(data) self.loop.call_soon_threadsafe(self.session.log_chunk, p, chunk) elif t == "session_key": key = bytes.fromhex(p.get("key_hex", "")) nonce = bytes.fromhex(p.get("nonce_hex", "")) off = int(p.get("offset", 0)) off_enc = int(p.get("offset_enc", 0)) off_dec = int(p.get("offset_dec", off)) flag = int(p.get("flag", 0)) this_id = p.get("this_id", "") self.loop.call_soon_threadsafe( self.session.record_session_key, key, nonce, off, flag, this_id, off_enc, off_dec, ) elif t == "status": print(f"[*] hook calls: {p.get('calls',0)} | " f"decoded: {self.session.decoded_seq} | " f"mapped: {len(self.session.msg_id_cache)}") # --------------------------------------------------------------------------- # main # --------------------------------------------------------------------------- async def run_with_session(session: Session, proxy_enabled: bool = True, decoder_enabled: bool = True) -> None: """Core event loop: starts proxy servers, attaches Frida, serves until cancelled. Accepts a pre-built Session so callers (e.g. the GUI) can subclass Session to intercept data.""" print("=" * 64) print(" Paralogue MITM (proxy + plaintext decoder)") print(f" decoded -> {session.decoded_path}") print(f" wire -> {session.wire_path}") print(f" chunks -> {session.chunks_path}") print("=" * 64) game_server = http_server = None if proxy_enabled: game_server = await asyncio.start_server( lambda r, w: handle_game_client(r, w, session), "0.0.0.0", GAME_PORT, reuse_address=True, ) print(f"[*] game proxy listening on 0.0.0.0:{GAME_PORT}") http_server = await asyncio.start_server( lambda r, w: handle_http_client(r, w, session), "0.0.0.0", HTTP_PORT, reuse_address=True, ) print(f"[*] http proxy listening on 0.0.0.0:{HTTP_PORT}") bridge: Optional[FridaBridge] = None if decoder_enabled: loop = asyncio.get_running_loop() bridge = FridaBridge(session, loop, with_redirect=proxy_enabled) await bridge.start() session.bridge = bridge # expose for GUI / callers print("[*] Ctrl+C to stop\n") stop_evt = asyncio.Event() async def serve_forever(): tasks = [] if game_server: tasks.append(asyncio.create_task(game_server.serve_forever())) tasks.append(asyncio.create_task(http_server.serve_forever())) tasks.append(asyncio.create_task(stop_evt.wait())) await asyncio.gather(*tasks, return_exceptions=True) try: await serve_forever() except KeyboardInterrupt: pass finally: if bridge: bridge.stop() if game_server: game_server.close() if http_server: http_server.close() session.close() print("\n[=] session summary") print(f" decoded messages: {session.decoded_seq}") print(f" wire packets: {session.wire_seq}") print(f" chunks: {session.chunk_seq}") print(f" msg_id mappings: {len(session.msg_id_cache)}") async def run(proxy_enabled: bool, decoder_enabled: bool, inject_items: bool = False) -> None: ts = int(time.time()) session = Session(ts) if inject_items: def combined(msg_id, head, body): for fn in (expand_card_bag_open_rsp_modifier, inject_unlock_functions_modifier, inject_role_attrs_modifier, inject_items_1_to_2000_modifier): r = fn(msg_id, head, body) if r is not None: return r return None session.s2c_rewriter = WireRewriter(modify_cb=combined, label="S->C") print("[*] S->C rewriter enabled: inject BagItem items " "+ saturate RoleListFullS2C attrs") await run_with_session(session, proxy_enabled, decoder_enabled) def main() -> None: ap = argparse.ArgumentParser(description="Paralogue MITM (proxy + decoder in one)") ap.add_argument("--no-proxy", action="store_true", help="skip the TCP proxy; only run the Frida decoder") ap.add_argument("--no-decoder", action="store_true", help="skip the Frida decoder; only run the TCP proxy") ap.add_argument("--inject-items", action="store_true", help="rewrite S->C BagItemFullS2C to append items " "1..2000 (client-side visualization only; " "server-side state unchanged)") args = ap.parse_args() proxy_enabled = not args.no_proxy decoder_enabled = not args.no_decoder if not (proxy_enabled or decoder_enabled): print("nothing to do (both proxy and decoder disabled)") sys.exit(1) if args.inject_items and not proxy_enabled: print("--inject-items requires the proxy (do not pass --no-proxy)") sys.exit(1) try: asyncio.run(run(proxy_enabled, decoder_enabled, inject_items=args.inject_items)) except KeyboardInterrupt: print("\n[*] stopped") if __name__ == "__main__": main()