yes
This commit is contained in:
commit
9c3189cac2
3219 files changed
+1984040
No files matched your search
@@ -0,0 +1,594 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
tcp_proxy_decrypt.py - MITM TCP proxy with ChaCha20 decryption/encryption.
|
||||
Extends tcp_proxy.py with ability to decrypt, parse, modify, and re-encrypt
|
||||
game server traffic once the ChaCha20 session key is captured.
|
||||
|
||||
Usage:
|
||||
1. Start this proxy
|
||||
2. Launch game + Frida redirect (redirect_and_capture.py)
|
||||
3. Run run_chacha_capture.py to capture the session key
|
||||
4. Proxy auto-loads key from captures/chacha_session_key.json
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import struct
|
||||
import time
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
|
||||
from Crypto.Cipher import ChaCha20
|
||||
|
||||
# Add parent dir for proto import
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
import paralogue_net_full_pb2 as pb
|
||||
from paralogue_decoder import (
|
||||
Stream, drain_stream, identify_body, msg_to_dict, short_repr,
|
||||
load_known_ids, save_known_ids,
|
||||
)
|
||||
|
||||
# Real server IPs
|
||||
REAL_SERVER_IPS = ['13.248.150.146', '35.71.128.233', '3.33.185.193', '76.223.57.31']
|
||||
DISPATCH_IP = '13.248.150.146'
|
||||
GAME_SERVER_IP = '3.33.185.193'
|
||||
|
||||
GAME_PORT = 11001
|
||||
HTTP_PORT = 18801
|
||||
|
||||
OUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'captures')
|
||||
os.makedirs(OUT_DIR, exist_ok=True)
|
||||
|
||||
KEY_FILE = os.path.join(OUT_DIR, 'chacha_session_key.json')
|
||||
KEYSTREAM_FILE = os.path.join(OUT_DIR, 'keystream.bin')
|
||||
|
||||
# Whether to modify packets (set True once we confirm decryption works)
|
||||
MODIFY_PACKETS = True
|
||||
|
||||
|
||||
def hexdump(data, width=16, limit=128):
|
||||
lines = []
|
||||
for i in range(0, min(len(data), limit), width):
|
||||
chunk = data[i:i+width]
|
||||
hx = ' '.join(f'{b:02x}' for b in chunk)
|
||||
asc = ''.join(chr(b) if 32 <= b < 127 else '.' for b in chunk)
|
||||
lines.append(f' {i:04x} {hx:<{width*3}} {asc}')
|
||||
if len(data) > limit:
|
||||
lines.append(f' ... +{len(data)-limit} bytes')
|
||||
return '\n'.join(lines)
|
||||
|
||||
|
||||
def parse_envelope(data):
|
||||
"""Parse outer protobuf envelope: [2B BE hdr_len][protobuf fields]"""
|
||||
if len(data) < 4:
|
||||
return None
|
||||
hdr_len = (data[0] << 8) | data[1]
|
||||
if hdr_len < 2 or 2 + hdr_len > len(data):
|
||||
return None
|
||||
hdr = data[2:2+hdr_len]
|
||||
fields = {}
|
||||
pos = 0
|
||||
try:
|
||||
while pos < len(hdr):
|
||||
byte = hdr[pos]; fn = byte >> 3; wt = byte & 7; pos += 1
|
||||
if wt == 0:
|
||||
val = 0; shift = 0
|
||||
while pos < len(hdr):
|
||||
b = hdr[pos]; val |= (b & 0x7f) << shift; shift += 7; pos += 1
|
||||
if (b & 0x80) == 0: break
|
||||
fields[fn] = val
|
||||
else:
|
||||
break
|
||||
except:
|
||||
return None
|
||||
return {'hdr_len': hdr_len, 'fields': fields, 'payload_off': 2 + hdr_len}
|
||||
|
||||
|
||||
# msg_id -> message name mapping (populated as we discover them)
|
||||
MSG_ID_NAMES = {
|
||||
1001: 'KEY_A',
|
||||
1002: 'KEY_B',
|
||||
}
|
||||
|
||||
|
||||
class ChaChaStream:
|
||||
"""Wraps ChaCha20 as a continuous stream cipher for one direction.
|
||||
|
||||
Per RESEARCH.md, PyCryptodome cannot reproduce the game's ChaCha20
|
||||
keystream from the raw key/nonce we capture -- OpenSSL transforms
|
||||
the key internally. We keep this class as a fallback but the proxy
|
||||
prefers `KeystreamFile` below when it's available.
|
||||
"""
|
||||
|
||||
def __init__(self, key: bytes, nonce: bytes):
|
||||
self.key = key
|
||||
self.nonce = nonce
|
||||
self.offset = 0
|
||||
self._cipher = ChaCha20.new(key=key, nonce=nonce)
|
||||
|
||||
def process(self, data: bytes) -> bytes:
|
||||
result = self._cipher.encrypt(data)
|
||||
self.offset += len(data)
|
||||
return result
|
||||
|
||||
def reset(self):
|
||||
self._cipher = ChaCha20.new(key=self.key, nonce=self.nonce)
|
||||
self.offset = 0
|
||||
|
||||
|
||||
class KeystreamFile:
|
||||
"""Keystream-based decryptor.
|
||||
|
||||
The Frida hook `capture_session_key.js` writes the ChaCha20 keystream
|
||||
to `captures/keystream.bin` at each stream offset. Both directions
|
||||
share the same keystream (per RESEARCH.md), so XOR-ing ciphertext
|
||||
against the bytes at its stream offset yields plaintext without
|
||||
needing PyCryptodome's key schedule to match.
|
||||
|
||||
Each direction maintains its own running `offset` counter -- TCP
|
||||
reassembly on the proxy side is not strictly byte-aligned to the
|
||||
game's internal stream, but because the keystream bytes we capture
|
||||
from Frida cover the same byte positions, reads stay in sync.
|
||||
"""
|
||||
|
||||
def __init__(self, path: str):
|
||||
self.path = path
|
||||
self._cache = b""
|
||||
self._mtime = 0.0
|
||||
self.offset = 0
|
||||
|
||||
def _ensure(self, upto: int) -> None:
|
||||
# Re-read whenever the file has been modified (Frida hook writes
|
||||
# fresh keystream on every new session and truncates at start).
|
||||
try:
|
||||
st = os.stat(self.path)
|
||||
except FileNotFoundError:
|
||||
self._cache = b""
|
||||
return
|
||||
if st.st_mtime != self._mtime or upto > len(self._cache):
|
||||
try:
|
||||
with open(self.path, "rb") as f:
|
||||
self._cache = f.read()
|
||||
self._mtime = st.st_mtime
|
||||
except FileNotFoundError:
|
||||
self._cache = b""
|
||||
|
||||
def process(self, data: bytes) -> bytes:
|
||||
# Proxy byte arrival races ahead of the in-process Frida hook by
|
||||
# a few ms. Poll briefly for the keystream file to reach the end
|
||||
# offset we need. Valid keystream bytes may be 0x00 themselves, so
|
||||
# we can't use a "non-zero" heuristic; we rely on file size growing
|
||||
# past `need_end` (the decoder always writes sequentially).
|
||||
need_end = self.offset + len(data)
|
||||
deadline = time.time() + 0.5
|
||||
while True:
|
||||
try:
|
||||
st = os.stat(self.path)
|
||||
if st.st_size >= need_end:
|
||||
self._ensure(need_end)
|
||||
break
|
||||
except FileNotFoundError:
|
||||
pass
|
||||
if time.time() >= deadline:
|
||||
self._ensure(need_end)
|
||||
break
|
||||
time.sleep(0.01)
|
||||
|
||||
out = bytearray(len(data))
|
||||
for i, b in enumerate(data):
|
||||
j = self.offset + i
|
||||
if j < len(self._cache):
|
||||
out[i] = b ^ self._cache[j]
|
||||
else:
|
||||
out[i] = b
|
||||
self.offset += len(data)
|
||||
return bytes(out)
|
||||
|
||||
def available(self) -> bool:
|
||||
return os.path.isfile(self.path) and os.path.getsize(self.path) > 0
|
||||
|
||||
|
||||
class GameProxy:
|
||||
def __init__(self):
|
||||
self.pkt_num = 0
|
||||
ts = int(time.time())
|
||||
self.capfile = os.path.join(OUT_DIR, f'decproxy_{ts}.jsonl')
|
||||
self.decoded_file = os.path.join(OUT_DIR, f'proxy_decoded_{ts}.jsonl')
|
||||
self.handshake_complete = False
|
||||
self.client_key_data = None
|
||||
self.server_key_data = None
|
||||
|
||||
# ChaCha20 streams (initialized when key is loaded)
|
||||
self.c2s_cipher = None # decrypt client->server
|
||||
self.s2c_cipher = None # decrypt server->client
|
||||
self.key_loaded = False
|
||||
self.key_check_time = 0
|
||||
|
||||
# Keystream-based fallback (preferred when available)
|
||||
self.c2s_ks = None
|
||||
self.s2c_ks = None
|
||||
self.using_keystream = False
|
||||
|
||||
# Packet counters for decrypted stream
|
||||
self.dec_pkt_num = 0
|
||||
|
||||
# Shared decoder state: per-direction Stream and msg_id cache,
|
||||
# plus a running sequence number for the decoded log.
|
||||
self.streams: dict[str, Stream] = {
|
||||
'C->S': Stream(label='C->S'),
|
||||
'S->C': Stream(label='S->C'),
|
||||
}
|
||||
self.msg_id_cache = load_known_ids()
|
||||
self._user_ids = set(self.msg_id_cache.keys())
|
||||
self.decoded_seq = 0
|
||||
self._decoded_fp = open(self.decoded_file, 'w', encoding='utf-8')
|
||||
print(f' Decoded log -> {self.decoded_file}')
|
||||
|
||||
def try_load_key(self):
|
||||
"""Try to initialise decryption.
|
||||
|
||||
Two sources:
|
||||
1. keystream.bin produced by the Frida keystream-capture hook
|
||||
(preferred -- it's a byte-for-byte XOR pad and works reliably)
|
||||
2. chacha_session_key.json with key+nonce (falls back to
|
||||
PyCryptodome, which per RESEARCH.md does not reproduce
|
||||
the game's keystream but we try anyway)
|
||||
"""
|
||||
if self.key_loaded:
|
||||
return True
|
||||
now = time.time()
|
||||
if now - self.key_check_time < 2:
|
||||
return False
|
||||
self.key_check_time = now
|
||||
|
||||
# Preferred: keystream file
|
||||
if os.path.isfile(KEYSTREAM_FILE) and os.path.getsize(KEYSTREAM_FILE) > 0:
|
||||
self.c2s_ks = KeystreamFile(KEYSTREAM_FILE)
|
||||
self.s2c_ks = KeystreamFile(KEYSTREAM_FILE)
|
||||
self.using_keystream = True
|
||||
self.key_loaded = True
|
||||
print(f'\n{"="*60}')
|
||||
print(f' *** Decryption via keystream.bin ({os.path.getsize(KEYSTREAM_FILE)}B available) ***')
|
||||
print(f'{"="*60}\n')
|
||||
return True
|
||||
|
||||
if not os.path.exists(KEY_FILE):
|
||||
return False
|
||||
|
||||
try:
|
||||
with open(KEY_FILE, 'r') as f:
|
||||
keys = json.load(f)
|
||||
if not keys:
|
||||
return False
|
||||
# Use the first captured key
|
||||
k = keys[0] if isinstance(keys, list) else keys
|
||||
key_hex = k['key_hex']
|
||||
nonce_hex = k['nonce_hex']
|
||||
key = bytes.fromhex(key_hex)
|
||||
nonce = bytes.fromhex(nonce_hex)
|
||||
|
||||
if len(key) != 32:
|
||||
print(f'[!] Bad key length: {len(key)}')
|
||||
return False
|
||||
|
||||
# ChaCha20 nonce can be 8 or 12 bytes
|
||||
if len(nonce) not in (8, 12):
|
||||
print(f'[!] Bad nonce length: {len(nonce)}, trying 8-byte trim')
|
||||
nonce = nonce[:8]
|
||||
|
||||
# Both directions use same key but may use different nonces
|
||||
# For now assume same key+nonce, we'll adjust if needed
|
||||
self.c2s_cipher = ChaChaStream(key, nonce)
|
||||
self.s2c_cipher = ChaChaStream(key, nonce)
|
||||
self.key_loaded = True
|
||||
|
||||
print(f'\n{"="*60}')
|
||||
print(f' *** ChaCha20 KEY LOADED ***')
|
||||
print(f' Key: {key_hex}')
|
||||
print(f' Nonce: {nonce_hex}')
|
||||
print(f'{"="*60}\n')
|
||||
return True
|
||||
except Exception as e:
|
||||
print(f'[!] Failed to load key: {e}')
|
||||
return False
|
||||
|
||||
def parse_packet_head(self, data):
|
||||
"""Parse a decrypted PacketHead protobuf."""
|
||||
try:
|
||||
ph = pb.PacketHead()
|
||||
ph.ParseFromString(data)
|
||||
return ph
|
||||
except Exception as e:
|
||||
return None
|
||||
|
||||
def try_parse_body(self, msg_id, body_data):
|
||||
"""Try to parse a protobuf body based on msg_id."""
|
||||
# We don't know the msg_id -> message type mapping yet.
|
||||
# Log raw protobuf fields for discovery.
|
||||
# As we discover mappings, add them here.
|
||||
result = {'msg_id': msg_id, 'raw_len': len(body_data)}
|
||||
try:
|
||||
# Generic protobuf decode attempt
|
||||
from google.protobuf import descriptor_pool, descriptor_pb2
|
||||
# For now just try known message types
|
||||
# We'll build the mapping as we see traffic
|
||||
result['hex_preview'] = body_data[:64].hex()
|
||||
except:
|
||||
pass
|
||||
return result
|
||||
|
||||
def log_packet(self, direction, data, label=''):
|
||||
"""Log a raw packet, attempt decryption if key is loaded."""
|
||||
self.pkt_num += 1
|
||||
ts = time.time()
|
||||
|
||||
# Check for handshake envelope
|
||||
env = parse_envelope(data)
|
||||
is_handshake = False
|
||||
if env and not self.handshake_complete:
|
||||
f = env['fields']
|
||||
msg_type = f.get(2, 0)
|
||||
if msg_type in (1001, 1002):
|
||||
is_handshake = True
|
||||
name = MSG_ID_NAMES.get(msg_type, f'type_{msg_type}')
|
||||
payload = data[env['payload_off']:]
|
||||
label = f'{name} route={f.get(1,0)} f4={f.get(4,0)} payload={len(payload)}B'
|
||||
|
||||
if msg_type == 1001:
|
||||
self.client_key_data = payload
|
||||
print(f' *** KEY_A: {len(payload)} bytes ***')
|
||||
elif msg_type == 1002:
|
||||
self.server_key_data = payload
|
||||
self.handshake_complete = True
|
||||
print(f' *** KEY_B: {len(payload)} bytes ***')
|
||||
self._save_keys()
|
||||
|
||||
# Try decryption for post-handshake data
|
||||
decrypted = None
|
||||
if self.handshake_complete and not is_handshake and self.key_loaded:
|
||||
if self.using_keystream:
|
||||
cipher = self.c2s_ks if direction == 'C->S' else self.s2c_ks
|
||||
else:
|
||||
cipher = self.c2s_cipher if direction == 'C->S' else self.s2c_cipher
|
||||
try:
|
||||
decrypted = cipher.process(data)
|
||||
self._log_decrypted(direction, decrypted, cipher_offset=cipher.offset - len(data))
|
||||
except Exception as e:
|
||||
print(f' [!] Decrypt error: {e}')
|
||||
|
||||
# Console output
|
||||
prefix = '>>>' if direction == 'C->S' else '<<<'
|
||||
enc_tag = ''
|
||||
if self.handshake_complete and not is_handshake:
|
||||
enc_tag = ' [DECRYPTED]' if decrypted else ' [encrypted]'
|
||||
print(f'[#{self.pkt_num:04d}] {prefix} {direction} {len(data):5d}B {label}{enc_tag}')
|
||||
|
||||
# Save to capture file
|
||||
entry = {
|
||||
'n': self.pkt_num, 'ts': ts, 'd': direction,
|
||||
'sz': len(data), 'hex': data.hex(), 'label': label
|
||||
}
|
||||
if decrypted:
|
||||
entry['dec_hex'] = decrypted.hex()
|
||||
with open(self.capfile, 'a') as f:
|
||||
f.write(json.dumps(entry) + '\n')
|
||||
|
||||
def _log_decrypted(self, direction, data, cipher_offset=0):
|
||||
"""Analyse decrypted data via the shared framing + identifier.
|
||||
|
||||
TCP reads can span multiple logical packets and/or slice one in the
|
||||
middle. We accumulate into a per-direction Stream keyed by cipher
|
||||
offset so framing holds across reads.
|
||||
"""
|
||||
self.dec_pkt_num += 1
|
||||
stream = self.streams[direction]
|
||||
stream.add(cipher_offset, data)
|
||||
|
||||
for head, body, _skipped in drain_stream(stream):
|
||||
self._emit_decoded(direction, head, body, cipher_offset)
|
||||
|
||||
def _emit_decoded(self, direction, head, body, cipher_offset):
|
||||
mid = int(head.msg_id)
|
||||
preferred = self.msg_id_cache.get(mid)
|
||||
name, parsed, score, cand, top = identify_body(body, preferred)
|
||||
|
||||
# auto-promote strong identifications into the cache
|
||||
if name and not preferred and score >= 60:
|
||||
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)
|
||||
else:
|
||||
fields_obj = {'_raw_hex': body.hex()}
|
||||
|
||||
self.decoded_seq += 1
|
||||
record = {
|
||||
'seq': self.decoded_seq,
|
||||
'ts': time.time(),
|
||||
'source': 'proxy',
|
||||
'direction': direction,
|
||||
'stream_offset': cipher_offset,
|
||||
'msg_id': mid,
|
||||
'msg_type': name or '<unknown>',
|
||||
'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,
|
||||
'top_candidates': [{'type': n, 'score': s} for n, s in top],
|
||||
'fields': fields_obj,
|
||||
}
|
||||
self._decoded_fp.write(json.dumps(record, ensure_ascii=False) + '\n')
|
||||
self._decoded_fp.flush()
|
||||
|
||||
print(f' [{self.decoded_seq:04d}] {direction} '
|
||||
f'msg_id={mid:<5d} {record["msg_type"]:<28s} '
|
||||
f'body={record["body_len"]:>5d}B {short_repr(fields_obj)}')
|
||||
|
||||
def _save_keys(self):
|
||||
"""Save handshake key material."""
|
||||
key_file = os.path.join(OUT_DIR, 'handshake_keys.json')
|
||||
keys = {
|
||||
'client_key_data': self.client_key_data.hex() if self.client_key_data else None,
|
||||
'server_key_data': self.server_key_data.hex() if self.server_key_data else None,
|
||||
'client_key_size': len(self.client_key_data) if self.client_key_data else 0,
|
||||
'server_key_size': len(self.server_key_data) if self.server_key_data else 0,
|
||||
'timestamp': time.time()
|
||||
}
|
||||
with open(key_file, 'w') as f:
|
||||
json.dump(keys, f, indent=2)
|
||||
print(f' *** Handshake keys saved to {key_file} ***')
|
||||
|
||||
|
||||
async def pipe(reader, writer, proxy, direction):
|
||||
"""Forward data, logging and optionally decrypting."""
|
||||
try:
|
||||
while True:
|
||||
data = await reader.read(65536)
|
||||
if not data:
|
||||
break
|
||||
|
||||
# Try loading key periodically
|
||||
proxy.try_load_key()
|
||||
|
||||
# Log (and decrypt for analysis)
|
||||
proxy.log_packet(direction, data)
|
||||
|
||||
# Forward original data (we don't modify yet until decryption is confirmed)
|
||||
writer.write(data)
|
||||
await writer.drain()
|
||||
except (ConnectionResetError, BrokenPipeError, asyncio.CancelledError):
|
||||
pass
|
||||
finally:
|
||||
try:
|
||||
writer.close()
|
||||
except:
|
||||
pass
|
||||
|
||||
|
||||
async def handle_game_client(client_reader, client_writer, proxy):
|
||||
"""Handle game client connection on port 11001."""
|
||||
addr = client_writer.get_extra_info('peername')
|
||||
print(f'[+] Game client connected from {addr}')
|
||||
|
||||
try:
|
||||
server_reader, server_writer = await asyncio.open_connection(
|
||||
GAME_SERVER_IP, GAME_PORT)
|
||||
print(f'[+] Connected to real server {GAME_SERVER_IP}:{GAME_PORT}')
|
||||
except Exception as e:
|
||||
print(f'[!] Failed to connect to real server: {e}')
|
||||
client_writer.close()
|
||||
return
|
||||
|
||||
c2s = asyncio.create_task(pipe(client_reader, server_writer, proxy, 'C->S'))
|
||||
s2c = asyncio.create_task(pipe(server_reader, client_writer, proxy, 'S->C'))
|
||||
await asyncio.gather(c2s, s2c, return_exceptions=True)
|
||||
print(f'[-] Game client {addr} disconnected')
|
||||
|
||||
|
||||
async def handle_http_client(client_reader, client_writer):
|
||||
"""Handle HTTP client on port 18801."""
|
||||
addr = client_writer.get_extra_info('peername')
|
||||
print(f'[+] HTTP client connected from {addr}')
|
||||
|
||||
try:
|
||||
server_reader, server_writer = await asyncio.open_connection(
|
||||
DISPATCH_IP, HTTP_PORT)
|
||||
except Exception as e:
|
||||
print(f'[!] Failed to connect to HTTP server: {e}')
|
||||
client_writer.close()
|
||||
return
|
||||
|
||||
async def fwd_c2s(r, w):
|
||||
try:
|
||||
while True:
|
||||
data = await r.read(65536)
|
||||
if not data:
|
||||
break
|
||||
try:
|
||||
first_line = data.split(b'\r\n')[0].decode(errors='replace')
|
||||
print(f' [HTTP] C->S {first_line}')
|
||||
except:
|
||||
pass
|
||||
w.write(data)
|
||||
await w.drain()
|
||||
except:
|
||||
pass
|
||||
|
||||
async def fwd_s2c(r, w):
|
||||
try:
|
||||
while True:
|
||||
data = await r.read(65536)
|
||||
if not data:
|
||||
break
|
||||
modified = data
|
||||
for real_ip in REAL_SERVER_IPS:
|
||||
if real_ip.encode() in modified:
|
||||
pad = b' ' * (len(real_ip) - 9)
|
||||
modified = modified.replace(
|
||||
real_ip.encode(), b'127.0.0.1' + pad)
|
||||
print(f' [HTTP] *** Replacing {real_ip} -> 127.0.0.1 ***')
|
||||
for pattern in [b'a6e3077dcfb5ca02d.awsglobalaccelerator.com']:
|
||||
if pattern in modified:
|
||||
replacement = b'127.0.0.1' + b' ' * (len(pattern) - 9)
|
||||
modified = modified.replace(pattern, replacement)
|
||||
try:
|
||||
first_line = modified.split(b'\r\n')[0].decode(errors='replace')
|
||||
print(f' [HTTP] S->C {first_line} ({len(modified)}B)')
|
||||
except:
|
||||
pass
|
||||
w.write(modified)
|
||||
await w.drain()
|
||||
except:
|
||||
pass
|
||||
|
||||
c2s = asyncio.create_task(fwd_c2s(client_reader, server_writer))
|
||||
s2c = asyncio.create_task(fwd_s2c(server_reader, client_writer))
|
||||
await asyncio.gather(c2s, s2c, return_exceptions=True)
|
||||
print(f'[-] HTTP client {addr} disconnected')
|
||||
|
||||
|
||||
async def main():
|
||||
proxy = GameProxy()
|
||||
|
||||
print('=' * 60)
|
||||
print(' Fallen Doll TCP Proxy (with decryption)')
|
||||
print('=' * 60)
|
||||
print(f' Game server: {GAME_SERVER_IP}:{GAME_PORT}')
|
||||
print(f' HTTP server: {DISPATCH_IP}:{HTTP_PORT}')
|
||||
print(f' Capture dir: {OUT_DIR}')
|
||||
print(f' Key file: {KEY_FILE}')
|
||||
if os.path.exists(KEY_FILE):
|
||||
print(f' Key file EXISTS - will load on first packet')
|
||||
else:
|
||||
print(f' Key file NOT FOUND - run run_chacha_capture.py to capture')
|
||||
print()
|
||||
|
||||
game_server = await asyncio.start_server(
|
||||
lambda r, w: handle_game_client(r, w, proxy),
|
||||
'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(
|
||||
handle_http_client,
|
||||
'0.0.0.0', HTTP_PORT, reuse_address=True)
|
||||
print(f'[*] HTTP proxy listening on 0.0.0.0:{HTTP_PORT}')
|
||||
|
||||
print('[*] Start the game now!')
|
||||
print()
|
||||
|
||||
async with game_server, http_server:
|
||||
await asyncio.gather(
|
||||
game_server.serve_forever(),
|
||||
http_server.serve_forever())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
asyncio.run(main())
|
||||
except KeyboardInterrupt:
|
||||
print('\n[*] Proxy stopped.')
|
||||
Reference in new issue
Block a user