1328 lines
56 KiB
Markdown
1328 lines
56 KiB
Markdown
# Fallen Doll / Paralogue - Reverse Engineering Research
|
||
|
||
## Engine & Build
|
||
|
||
- **Unreal Engine 5.5** (custom build from `D:\UnrealEngine\UnrealEngine55\`)
|
||
- **Binary**: `Paralogue-Win64-Shipping.exe` (347 MB)
|
||
- **Base address**: `0x140000000`
|
||
- **IDA database files** (.id0/.id1/.id2/.nam/.til) present alongside binary
|
||
- **Symbols**: Stripped (Shipping build)
|
||
|
||
## Game Directory Layout
|
||
|
||
```
|
||
Operation Lovecraft Fallen Doll Playtest/
|
||
├── Engine/
|
||
│ ├── Binaries/
|
||
│ │ ├── Win64/EOSSDK-Win64-Shipping.dll (18 MB)
|
||
│ │ └── ThirdParty/
|
||
│ │ ├── MsQuic/v220/win64/msquic.dll
|
||
│ │ └── Steamworks/Steamv157/Win64/steam_api64.dll
|
||
│ ├── Config/StagedBuild_Paralogue.ini
|
||
│ └── Plugins/NNE/
|
||
├── Paralogue/
|
||
│ ├── Binaries/Win64/
|
||
│ │ ├── Paralogue-Win64-Shipping.exe
|
||
│ │ ├── HLog/net.protocol (UTF-16LE: "codeserver")
|
||
│ │ ├── HLog/code.server (UTF-16LE: "Public")
|
||
│ │ ├── boost_*.dll (multiple boost libs)
|
||
│ │ └── D3D12/, DML/, OpenColorIO, tbb, tbbmalloc
|
||
│ ├── Content/Paks/ (Pak1-Pak5.pak)
|
||
│ ├── Plugins/NVIDA/ (DLSS, Streamline)
|
||
│ └── Saved/ (CamConf.config, CamPos.config, Studio.config)
|
||
└── FallenDollLauncher.exe
|
||
```
|
||
|
||
## Network Architecture - Three Layers
|
||
|
||
### Layer 1: HTTP Dispatch Server (port 18801)
|
||
|
||
- **Host**: `dispatch.projecthelius.com:18801` (resolves to `13.248.150.146` via AWS Global Accelerator)
|
||
- **Protocol**: Plain HTTP/1.1 (no TLS)
|
||
- **User-Agent**: `Paralogue/UE5-CL-0 (http-eventloop) Windows/10.0.19044.1.256.64bit`
|
||
- **Known endpoint**: `GET /get_notice` - returns JSON with game news/patch notes (~76KB)
|
||
- **Content-Type**: `application/json; charset=utf-8`
|
||
- **Fully interceptable** with any HTTP proxy (Fiddler, mitmproxy, etc.)
|
||
|
||
### Layer 2: Custom Game Server (port 11001)
|
||
|
||
- **Host**: `35.71.128.233:11001` (AWS Global Accelerator)
|
||
- **Protocol**: Custom binary protocol over TCP (NOT TLS)
|
||
- **Encryption**: ChaCha20 (key exchanged via RSA during handshake)
|
||
- **Serialization**: Protocol Buffers (protobuf3)
|
||
- **This is where ALL game state lives** (profiles, unlocks, inventory, etc.)
|
||
|
||
### Layer 3: Epic Online Services (EOS) + UE5 Replication
|
||
|
||
- **EOSSDK-Win64-Shipping.dll** at `0x7ff9771d0000`
|
||
- Used for: Auth, P2P relay, Lobbies, Sessions, Presence, Ecom, Achievements
|
||
- **EOS P2P** uses DTLS - invisible to HTTP debuggers
|
||
- UE5 replication runs over EOS P2P for room sync (player movement, state)
|
||
|
||
## Port 11001 Protocol Details
|
||
|
||
### Wire Format (Outer Envelope - before encryption)
|
||
|
||
```
|
||
[2-byte BE header_length][protobuf envelope][payload]
|
||
```
|
||
|
||
Protobuf envelope fields:
|
||
| Field | Type | Meaning |
|
||
|-------|--------|---------|
|
||
| 1 | varint | MsgRoute (0=GAME, 1=ROOM) |
|
||
| 2 | varint | MsgType (1=KEY_A, 2=KEY_B, 3=PROTO_CONTROL, 4=SYNC) |
|
||
| 4 | varint | Additional param (key size for handshake) |
|
||
|
||
### Connection Handshake
|
||
|
||
1. TCP connect to game server (port 11001)
|
||
2. **C->S KEY_A** (MsgType=1): 778B total = 10B header + 768B RSA-encrypted payload
|
||
3. **S->C KEY_B** (MsgType=2): 295B total = 10B header + 285B response
|
||
4. Session key established → all subsequent traffic is ChaCha20 encrypted
|
||
|
||
### Post-Handshake Encrypted Messages
|
||
|
||
After decryption, each message has:
|
||
```
|
||
[PacketHead protobuf][message body protobuf]
|
||
```
|
||
|
||
PacketHead fields:
|
||
- `packet_id` (uint32) - packet sequence
|
||
- `msg_id` (uint32) - identifies the protobuf message type
|
||
- `flag` (uint32)
|
||
- `body_len` (uint32) - length of the body protobuf
|
||
- `total_pack_count` (uint32) - for split messages
|
||
- `seq_id` (uint32)
|
||
|
||
### Encryption: ChaCha20
|
||
|
||
- Key and IV delivered in `VerifyLoginTokenRsp` message (fields 18, 19)
|
||
- `chacha20_key` (bytes, field 18)
|
||
- `chacha20_iv` (bytes, field 19)
|
||
- NOT AES-GCM as initially suspected (AESGCMHandlerComponent is UE5 built-in but game uses custom ChaCha20)
|
||
|
||
### Observed Traffic Pattern
|
||
|
||
| Time | Dir | Size | Meaning |
|
||
|------|-----|------|---------|
|
||
| +0.0s | C->S | 778B | KEY_A handshake |
|
||
| +0.6s | S->C | 295B | KEY_B response |
|
||
| +0.6s | C->S | 7B | First encrypted request |
|
||
| +0.9s | S->C | 51B | Encrypted response |
|
||
| +3.9s | C->S | 9B | Request (PlayerMainDataReq?) |
|
||
| +4.2s | S->C | 3314B | Big data dump (FullS2C messages) |
|
||
| every ~5s | C->S 16B / S->C 25B | Encrypted ping/pong keepalive |
|
||
|
||
## Authentication Flow
|
||
|
||
1. Steam provides auth ticket
|
||
2. Client sends `UePlayerLoginReq` with `steamToken` to game server
|
||
3. Server responds `UePlayerLoginRsp` (name, player_id, recognition map)
|
||
4. Client sends `VerifyLoginTokenReq` (login_token, appName)
|
||
5. Server responds `VerifyLoginTokenRsp` (user_id, login_token, **chacha20_key**, **chacha20_iv**)
|
||
6. Server pushes `VerifyLoginTokenExtS2C` (ban status, config version, server open status)
|
||
7. Server pushes cascade of `*FullS2C` messages with complete player state
|
||
|
||
## Server-Pushed State Messages (after login)
|
||
|
||
| Message | Contents |
|
||
|---------|----------|
|
||
| `RoleListFullS2C` | All characters with `RoleCell` (name, is_unlock, stats, clothes) |
|
||
| `BagItemFullS2C` | Full inventory (BaseItem list, guarantee counters) |
|
||
| `AchievementFullS2C` | Achievement progress |
|
||
| `BattlePassFullS2C` | Battle pass level, premium status, claimed rewards |
|
||
| `LearnCardInfoFullS2C` | Learned/borrowed cards |
|
||
| `PlayerExpFullS2C` / `PlayerExpLevelFullS2C` | Player XP/level |
|
||
| `ShopUpdateFullS2C` | Shop state |
|
||
| `SanityFullS2C` | Sanity system |
|
||
| `TaskUpdateFullS2C` | Quest/task progress |
|
||
| `WelfareInfoFullS2C` | Welfare/daily rewards |
|
||
| `PlayerMainDataRsp` | Player name, unlockFunctions, online state |
|
||
|
||
## Key Data Structures for Unlocking
|
||
|
||
### RoleCell (character data)
|
||
```protobuf
|
||
message RoleCell {
|
||
string name = 1; // character name
|
||
uint32 cur_stamina = 2;
|
||
uint32 favor_exp = 4;
|
||
uint32 favor_lv = 5;
|
||
bool is_unlock = 10; // ← THE UNLOCK FLAG
|
||
bool is_h_card = 13;
|
||
map<uint32, uint32> attrs = 20;
|
||
repeated ClothesCell worn_clothes = 21;
|
||
FemaleAppearance appearance = 23;
|
||
}
|
||
```
|
||
|
||
### Recognition (Patreon/VIP tiers)
|
||
```protobuf
|
||
// In UePlayerLoginRsp:
|
||
map<uint32, int64> recognition = 5;
|
||
// Also synced to other players via AddPlayerS2C.recognition
|
||
```
|
||
|
||
### PlayerMainDataRsp
|
||
```protobuf
|
||
message PlayerMainDataRsp {
|
||
repeated uint32 unlockFunctions = 6; // unlocked game features
|
||
NetworkOnlineState online_state = 23;
|
||
}
|
||
```
|
||
|
||
## Useful String Addresses (RVAs from base 0x140000000)
|
||
|
||
### Protobuf File Descriptors (in-memory, for schema extraction)
|
||
| File | RVA |
|
||
|------|-----|
|
||
| `common.proto` (43 msgs, 11 enums) | `0x80fd870` |
|
||
| `enum.proto` (0 msgs, 12 enums) | `0x8105dd0` |
|
||
| `player.proto` (155 msgs, 1 enum) | `0x810ef00` |
|
||
| `ueroom.proto` (41 msgs, 0 enums) | `0x8117f70` |
|
||
|
||
### MsgType Enum Strings
|
||
| String | RVA |
|
||
|--------|-----|
|
||
| `MsgType_NONE` | `0x80fed13` |
|
||
| `MsgType_KEY_A` | `0x80fed25` |
|
||
| `MsgType_KEY_B` | `0x80fed38` |
|
||
| `MsgType_PROTO_CONTROL` | `0x80fed4b` |
|
||
| `MsgType_SYNC` | `0x80fed66` |
|
||
|
||
### AES-GCM Handler Strings (UE5 built-in, may not be used for game server)
|
||
| String | RVA |
|
||
|--------|-----|
|
||
| `EAESGCMNetResult::AESMissingIV` | `0x80a5300` |
|
||
| `EAESGCMNetResult::AESMissingAuthTag` | `0x80a5320` |
|
||
| `EAESGCMNetResult::AESMissingPayload` | `0x80a5348` |
|
||
| `EAESGCMNetResult::AESDecryptionFailed` | `0x80a5370` |
|
||
| `EAESGCMNetResult::AESZeroLastByte` | `0x80a5398` |
|
||
|
||
### Key Protobuf Message Name Strings
|
||
| String | RVA |
|
||
|--------|-----|
|
||
| `ParalogueNet.UePlayerLoginRsp` | `0x8118227` |
|
||
| `ParalogueNet.PlayerMainDataRsp` | `0x8116398` |
|
||
| `ParalogueNet.VerifyLoginTokenRsp` | `0x81161d0` |
|
||
| `ParalogueNet.BagItemFullS2C` | `0x810fead` |
|
||
| `ParalogueNet.RoleListFullS2C` | `0x8111f42` |
|
||
| `MsgRoute_GAME` | `0x80ff984` |
|
||
|
||
### Game Server Classes (from debug strings)
|
||
| String | Source Path |
|
||
|--------|------------|
|
||
| `AGM_RoomBase` | Game mode for rooms |
|
||
| `ARoomDataBase` | Replicated room state actor |
|
||
| `ARoomManagerBase` | Player list management |
|
||
| `URoomMatchSystemProxy` | Matchmaking proxy |
|
||
| `IpNetDriver` | `Engine\Plugins\Online\OnlineSubsystemUtils\...\IpNetDriver.cpp` |
|
||
| `EOSSDKManager` | `Engine\Plugins\Online\EOSShared\...\EOSSDKManager.cpp` |
|
||
| `PacketHandler` | `Engine\Source\Runtime\PacketHandlers\...\PacketHandler.cpp` |
|
||
|
||
## Runtime Module Addresses (from Frida, session-specific)
|
||
|
||
| Module | Base | Size |
|
||
|--------|------|------|
|
||
| `Paralogue-Win64-Shipping.exe` | `0x140000000` | 351,141,888 |
|
||
| `EOSSDK-Win64-Shipping.dll` | `0x7ff9771d0000` | 18,997,248 |
|
||
| `steam_api64.dll` | `0x7ff9afbe0000` | 311,296 |
|
||
| `ws2_32.dll` | `0x7ffa2dfa0000` | 438,272 |
|
||
|
||
### EOS P2P Exports (for hooking)
|
||
| Function | Address |
|
||
|----------|---------|
|
||
| `EOS_P2P_SendPacket` | `0x7ff9777f0ca0` |
|
||
| `EOS_P2P_ReceivePacket` | `0x7ff9777f0d50` |
|
||
| `EOS_P2P_AcceptConnection` | `0x7ff9777f10b0` |
|
||
| `EOS_P2P_SetRelayControl` | `0x7ff9777f12f0` |
|
||
|
||
## UE5 Plugins Used
|
||
|
||
- `/Script/OnlineSubsystem`
|
||
- `/Script/OnlineSubsystemSteam`
|
||
- `/Script/AdvancedSessions` (Blueprint session wrapper)
|
||
- `/Script/AdvancedSteamSessions`
|
||
- `/Script/SteamSockets`
|
||
- `/Script/EOSShared`
|
||
- `/Script/TcpSocketPlugin` (custom TCP for game server)
|
||
- `/Script/PacketHandler`
|
||
- `/Script/AESGCMHandlerComponent`
|
||
- `/Script/OodleNetworkHandlerComponent`
|
||
|
||
## Server Configuration
|
||
|
||
### Server Types
|
||
```
|
||
EGameServerType::Prod
|
||
EGameServerType::Dev
|
||
EGameServerType::Pioneer
|
||
EGameServerType::Debug
|
||
```
|
||
|
||
### Server Regions
|
||
```
|
||
EGameServerRegion::Asia
|
||
EGameServerRegion::America
|
||
EGameServerRegion::Europe
|
||
EGameServerRegion::Default
|
||
```
|
||
|
||
### GM/Admin System
|
||
- `GmCodeReq` / `GmCodeRsp` - admin command execution
|
||
- `OperateCmdType_GM_CODE` - GM code command type
|
||
- `OperateCmdType_ACTION` - action command type
|
||
- `OperateCmdData` has fields: trace_id, cmd_type, gm_code, data
|
||
|
||
## DNS Resolutions
|
||
|
||
| Domain | IP | Purpose |
|
||
|--------|-----|---------|
|
||
| `dispatch.projecthelius.com` | `13.248.150.146` | HTTP dispatch/notice (port 18801) |
|
||
| `prod-game-latency-hk.projecthelius.com` | `18.162.165.236` (EC2 ap-east-1) | Latency check |
|
||
| `patreon.projecthelius.com` | `172.67.68.105` (Cloudflare) | Patreon binding API |
|
||
| `a6e3077dcfb5ca02d.awsglobalaccelerator.com` | `13.248.150.146` | AWS GA for game server |
|
||
| Alert endpoint | `ec2-18-166-229-48.ap-east-1.compute.amazonaws.com` | `/alert` endpoint |
|
||
|
||
## HTTPS Traffic (port 443)
|
||
|
||
- Uses **libcurl 8.4.0** with OpenSSL
|
||
- `SSLKEYLOGFILE` environment variable IS supported (string present in binary)
|
||
- Set `SSLKEYLOGFILE=C:\keys.log` before launching game to dump TLS master secrets
|
||
- Feed to Wireshark: Edit → Preferences → Protocols → TLS → Pre-Master-Secret log
|
||
|
||
## Extracted Protocol Schema
|
||
|
||
Full `.proto` file saved to: `frida_hooks/paralogue_net_full.proto`
|
||
- **239 messages** across 4 proto files
|
||
- **24 enums**
|
||
- **1704 lines**
|
||
|
||
## Tools Setup
|
||
|
||
### Frida API Notes (Windows x64 gotchas)
|
||
- `Module.findExportByName()` doesn't work reliably → use `mod.enumerateExports()` instead
|
||
- On x64 Windows, do NOT specify ABI for `NativeFunction` (no 'stdcall' / 'win64') → just omit it
|
||
- `readUtf8String()` crashes on non-UTF8 bytes → read as ByteArray and decode manually
|
||
- `Memory.scanSync()` on 350MB binary times out → limit scan range or search smaller sections
|
||
- Background python processes hold ports after crash → `kill -9 PID` or wait for TIME_WAIT
|
||
- Python stdout buffering when redirected to file → use `-u` flag for unbuffered output
|
||
- `Backtracer.ACCURATE` works for call stacks, `FUZZY` as fallback
|
||
|
||
### Python & Frida
|
||
- Python 3.13: `X:\Users\user\AppData\Local\Programs\Python\Python313\python.exe`
|
||
- Frida 17.9.1, frida-tools 14.8.1 installed via pip
|
||
- protobuf 6.33.6 (downgraded from 7.34.1 for grpcio-tools compat)
|
||
- pycryptodome 3.23.0 (for ChaCha20 - though not directly usable for game's impl)
|
||
- grpcio-tools 1.80.0 (for protoc compilation)
|
||
- frida-ps: `X:\Users\user\AppData\Local\Programs\Python\Python313\Scripts\frida-ps.exe`
|
||
|
||
### IDA Pro
|
||
- IDA Professional 9.2: `X:\Program Files\IDA Professional 9.2\`
|
||
- IDB: `C:\SteamLibrary\...\Paralogue-Win64-Shipping.exe.i64`
|
||
- Image base: `0x140000000` (Frida RVA + 0x140000000 = IDA VA)
|
||
- MCP server connected on port 13337
|
||
- Hex-Rays decompiler available and working
|
||
|
||
### Scripts (in `X:\Users\user\fallendoll\frida_hooks\`)
|
||
| File | Purpose |
|
||
|------|---------|
|
||
| `sniff_gameserver.js` | Hooks ws2_32 recv/send + EOS P2P on port 11001 |
|
||
| `run_sniffer.py` | Python runner for sniff_gameserver.js with packet decoding |
|
||
| `capture_handshake.js` | Hooks connect/recv/send, captures full handshake |
|
||
| `capture_handshake.py` | Runner for capture_handshake.js, auto-attaches to game |
|
||
| `redirect_connect.js` | **Hooks ws2_32!connect(), rewrites port 11001 dest IP to 127.0.0.1** |
|
||
| `redirect_and_capture.py` | Runner for redirect_connect.js, waits for game process |
|
||
| `tcp_proxy.py` | MITM TCP proxy on ports 11001+18801, logs all traffic, parses KEY_A/KEY_B |
|
||
| `tcp_proxy_decrypt.py` | **Enhanced proxy with ChaCha20 decryption support** |
|
||
| `capture_session_key.js` | **Hooks game encrypt wrapper, captures plaintext + keystream via XOR** |
|
||
| `run_key_capture.py` | **Runner for capture_session_key.js, saves keystream to file** |
|
||
| `capture_chacha_key.js` | Earlier attempt: hooks ChaCha20 block function (superseded) |
|
||
| `run_chacha_capture.py` | Earlier runner for chacha key capture (superseded) |
|
||
| `decrypt_capture.py` | Offline decryption tool for testing keys against captures |
|
||
| `paralogue_net_full.proto` | Reconstructed protobuf schema (239 msgs, 24 enums) |
|
||
| `paralogue_net_full_pb2.py` | Compiled protobuf Python module |
|
||
|
||
### Captures (in `frida_hooks/captures/`)
|
||
| File | Contents |
|
||
|------|----------|
|
||
| `proxy_*.jsonl` | Full session capture with handshake (JSONL, one packet per line) |
|
||
| `decproxy_*.jsonl` | Capture from decrypt-capable proxy (includes dec_hex field) |
|
||
| `client_key.bin` | 768B KEY_A payload (RSA-encrypted client key material) |
|
||
| `server_key.bin` | 285B KEY_B payload (server key response) |
|
||
| `handshake_keys.json` | Key material summary |
|
||
| `chacha_session_key.json` | Captured ChaCha20 key+nonce (per-session, from Frida hook) |
|
||
| `keystream.bin` | Captured keystream bytes at stream offsets (for proxy XOR) |
|
||
| `chacha_state_*.bin` | Raw ChaCha20 state dumps from block function |
|
||
| `http_response_*.bin` | Raw HTTP responses from dispatch server |
|
||
| `fdp_blob.bin` | Raw protobuf FileDescriptorProto blob |
|
||
| `paralogue_net_full.proto` | Reconstructed .proto schema (239 msgs, 24 enums) |
|
||
|
||
## Attack Vectors (for custom server / proxy)
|
||
|
||
### Option A: Frida In-Process Modification (RECOMMENDED - simplest)
|
||
1. Hook game's decrypt wrapper at RVA `0x49A2EB0` (**DONE - working**)
|
||
2. In `onLeave`, read decrypted plaintext from data buffer
|
||
3. Parse protobuf, modify target fields (is_unlock, recognition, etc.)
|
||
4. Write modified protobuf back to same buffer
|
||
5. Game processes modified data as if server sent it
|
||
6. **No encryption/decryption needed** - we modify after decrypt
|
||
|
||
### Option B: MITM Proxy with Keystream XOR (PARTIALLY WORKING)
|
||
1. TCP proxy captures handshake and all encrypted traffic (**DONE**)
|
||
2. Frida hook captures keystream via XOR of ciphertext/plaintext (**DONE**)
|
||
3. Proxy uses keystream to decrypt → modify → re-encrypt
|
||
4. **Issue**: keystream must be captured in real-time from same session
|
||
5. Requires coordination between Frida hook and proxy process
|
||
|
||
### Option C: MITM Proxy with RSA Key Replacement
|
||
1. Replace RSA public key in binary with our own
|
||
2. MITM the KEY_A/KEY_B handshake, derive ChaCha20 key ourselves
|
||
3. Full decrypt/modify/re-encrypt capability
|
||
4. **Not yet attempted** - requires finding RSA key in binary
|
||
|
||
## Call Stack for Game Server Socket (Frida backtrace)
|
||
|
||
```
|
||
recv (ws2_32.dll)
|
||
<- 0x18a5a0e (UE5 socket recv wrapper)
|
||
<- 0x49bca46 (game socket read helper)
|
||
<- 0x49bd167 (read 2-byte length prefix) \
|
||
<- 0x49bd1b0 (read 8-byte header) } inside packet reader at 0x49bd0f0
|
||
<- 0x49bd34e (read N-byte payload) /
|
||
<- 0x49c7d56 (message receive loop - calls decrypt+dispatch after read)
|
||
<- 0x49c6388 (network tick/pump)
|
||
<- 0x12952f7 (engine tick)
|
||
```
|
||
|
||
### Key Function RVAs (for IDA analysis)
|
||
| RVA | Role |
|
||
|-----|------|
|
||
| `0x49bd0f0` | Packet reader function (reads 2B+8B+NB from socket) |
|
||
| `0x49bca46` | Socket read helper (calls ws2_32!recv) |
|
||
| `0x49c7d56` | Post-read handler (checks result, calls 0x499ec90) |
|
||
| `0x49c6388` | Network tick function |
|
||
| `0x499ec90` | Called after successful packet read (dispatch?) |
|
||
| `0x49ceb6f` | Send path (calls ws2_32!send) |
|
||
| `0x49bbdb3` | Message send wrapper |
|
||
| `0x49cf045` | Send orchestrator |
|
||
| `0x18a5a0e` | UE5 FSocket::Recv wrapper |
|
||
| `0x18a5ff3` | UE5 FSocket::Send wrapper |
|
||
|
||
### Recv Pattern (ping/pong)
|
||
```
|
||
RECV 2B (req=2) - encrypted length/type prefix
|
||
RECV 8B (req=8) - encrypted header
|
||
RECV 16B (req=16) - encrypted payload body
|
||
SEND 17B - encrypted response (sent as single buffer)
|
||
```
|
||
|
||
### Connection Object (at rcx = 0x7ca70e10 in test session)
|
||
- `+0x58`: pointer to rdx arg structure
|
||
- `+0x68`: pointer to UTF-16 server hostname ("prod-gam...")
|
||
- `+0x80..0x98`: buffer pointers (zeroed between packets)
|
||
- `+0xa0`: pointer to packet tracking structure
|
||
- `+0xb0`: pointer to connection state
|
||
- `+0xc0`: value 3 (connection state? MsgType_PROTO_CONTROL?)
|
||
|
||
### ChaCha20 Implementation
|
||
- Located in `.rsrc` section (executable)
|
||
- Scalar path entry: RVA `0xc25161` (`mov eax, 0x61707865`)
|
||
- Function entry (with CPU feature check): RVA `0xc250e8`
|
||
- AVX path: RVA `0xc254d4` (used on modern CPUs)
|
||
- `"expand 32-byte k"` constant at RVA `0xc24440`
|
||
- 102 ChaCha20 states found in heap (mostly from OpenSSL TLS connections)
|
||
|
||
## Captured Traffic Analysis (from Frida hooks)
|
||
|
||
### Framing (post-encryption)
|
||
All data on port 11001 is encrypted. The recv pattern is:
|
||
```
|
||
[2B prefix] [5-7B header] [NB body]
|
||
```
|
||
The 2-byte prefix is NOT a plaintext length - it's encrypted.
|
||
|
||
### Initial Connection Burst (S->C)
|
||
| Msg | Total Size | Payload | Likely Content |
|
||
|-----|-----------|---------|----------------|
|
||
| 1 | 546B | 538B | KEY_B + VerifyLoginTokenRsp (contains ChaCha20 key!) |
|
||
| 4 | 1179B | 1171B | RoleListFullS2C + BagItemFullS2C |
|
||
| 5 | 1175B | 1167B | AchievementFullS2C + BattlePassFullS2C + more |
|
||
| 6 | 297B | 289B | TaskUpdateFullS2C + ShopUpdateFullS2C |
|
||
|
||
### Steady State (ping/pong every ~5s)
|
||
```
|
||
S->C: 2B + 7B + 16B = 25B (pong)
|
||
C->S: 16B (ping)
|
||
```
|
||
|
||
### MITM Proxy Setup (WORKING)
|
||
|
||
The game server IP is NOT from DNS - it's baked in or from dispatch response.
|
||
The game connects to `a09484ac4d76eba25.awsglobalaccelerator.com` (3.33.185.193) for port 11001.
|
||
|
||
**Working redirect method**: Frida hook on `ws2_32!connect()` to rewrite destination IP.
|
||
|
||
```
|
||
# Required:
|
||
# 1. hosts file: 127.0.0.1 dispatch.projecthelius.com (for HTTP on 18801)
|
||
# 2. Frida redirect_connect.js: hooks connect(), rewrites port 11001 dest to 127.0.0.1
|
||
# 3. tcp_proxy.py: listens on 11001+18801, forwards to real servers, logs everything
|
||
```
|
||
|
||
**Captured handshake** (proxy_*.jsonl):
|
||
- Packet #1: KEY_A (C->S) 778B = 10B envelope + 768B RSA-encrypted client key
|
||
- Packet #2: KEY_B (S->C) 295B = 10B envelope + 285B server response
|
||
- Packet #3+: ChaCha20 encrypted session data
|
||
|
||
### Game Server Domains
|
||
| Domain | IP | Purpose |
|
||
|--------|-----|---------|
|
||
| `dispatch.projecthelius.com` | CNAME to `prod-game-ga.projecthelius.com` | HTTP dispatch (18801) |
|
||
| `a6e3077dcfb5ca02d.awsglobalaccelerator.com` | 13.248.150.146, 35.71.128.233 | Dispatch GA endpoint |
|
||
| `a09484ac4d76eba25.awsglobalaccelerator.com` | 3.33.185.193 | Game server GA endpoint (11001) |
|
||
|
||
## Next Steps (TODO)
|
||
|
||
### Immediate: Build keystream-based MITM proxy
|
||
**STATUS: Plaintext capture WORKING. Keystream capture WORKING.**
|
||
|
||
The current approach captures plaintext via Frida hook on the game's encrypt/decrypt
|
||
wrapper. Next steps to build a full modify-and-forward proxy:
|
||
|
||
1. **Extend Frida hook to intercept AND modify data in-place**
|
||
- Hook onEnter: read ciphertext, compute keystream
|
||
- Decrypt to plaintext, parse protobuf, modify fields
|
||
- Re-encrypt with same keystream, write back to buffer
|
||
- This avoids the proxy needing to decrypt at all
|
||
|
||
2. **Alternatively: keystream-based proxy**
|
||
- Frida hook saves keystream to shared memory/file
|
||
- Proxy reads keystream, XORs with ciphertext to get plaintext
|
||
- Modifies protobuf, XORs with keystream to re-encrypt
|
||
- Forwards modified ciphertext to server/client
|
||
|
||
3. **Parse the packet framing** (from confirmed decrypted data):
|
||
- Each message starts with 2-byte length prefix (e.g., `0005` = 5 bytes follow)
|
||
- Then protobuf body with msg_id and payload
|
||
- Need to map msg_id values to protobuf message types
|
||
|
||
4. **Implement protobuf modification**:
|
||
- `RoleCell.is_unlock = true` for all characters
|
||
- `recognition` map for VIP/Patreon tiers
|
||
- `BagItemFullS2C` for inventory items
|
||
|
||
### Confirmed Decrypted Message Sequence (login)
|
||
|
||
| # | Offset | Len | Dir | Content |
|
||
|---|--------|-----|-----|---------|
|
||
| 1 | 0 | 2 | C→S | Length prefix: 5 |
|
||
| 2 | 2 | 5 | C→S | msg_id=0xd6=214, len=0x16=22 |
|
||
| 3 | 7 | 22 | C→S | Envelope: route=1, field2=1, field4=-1, field8="1775713120" |
|
||
| 4 | 29 | 2 | S→C | Length prefix: 7 |
|
||
| 5 | 31 | 7 | S→C | msg_id=0xec07=1004, len=42 |
|
||
| 6 | 38 | 42 | S→C | PlayerLoginRsp: "LocalRegion", name="MRLOKOP" |
|
||
| 7 | 80 | 2 | S→C | Length prefix: 6 |
|
||
| 8 | 82 | 6 | S→C | msg_id=0xc608=1094, len=0x9a04=538 |
|
||
| 9 | 88 | 538 | S→C | VerifyLoginTokenRsp or similar (contains timestamps) |
|
||
| 10-14 | 626+ | var | S→C | More setup messages |
|
||
| 15 | 643 | 1171 | S→C | **RoleListFullS2C**: "Alet", "Celia" + character data |
|
||
| 18 | 1822 | 1167 | S→C | BagItemFullS2C or AchievementFullS2C |
|
||
| 21 | 2997 | 290 | S→C | More FullS2C data |
|
||
| 24 | 3294 | 22 | S→C | Contains "Alet" reference |
|
||
| 39 | 3380 | 21 | S→C | PlayerMainDataRsp: "MRLOKOP" |
|
||
|
||
### Option B: In-process Frida modification (RECOMMENDED)
|
||
Instead of a MITM proxy, modify packets directly in the game process:
|
||
1. Hook the decrypt wrapper at RVA `0x49A2EB0`
|
||
2. After decryption (in onLeave), parse the plaintext protobuf
|
||
3. If it's RoleListFullS2C → set all `is_unlock = true`
|
||
4. If it's UePlayerLoginRsp → modify `recognition` map
|
||
5. Re-serialize the modified protobuf back to the buffer
|
||
6. The game reads the modified data as if the server sent it
|
||
|
||
This is simpler than a proxy because:
|
||
- No need to handle keystream/encryption
|
||
- No need to maintain cipher state sync
|
||
- Works regardless of key rotation or re-keying
|
||
- Single Frida script, no proxy infrastructure needed
|
||
|
||
### Option C: Full Custom Server (future)
|
||
1. Implement KEY_A/KEY_B RSA handshake
|
||
2. Implement ChaCha20 encryption layer (need to reverse OpenSSL key setup)
|
||
3. Implement PacketHead framing
|
||
4. Respond to all Req messages with crafted Rsp/S2C messages
|
||
5. All characters unlocked, all items granted, max stats
|
||
|
||
## Failed Approaches & Lessons Learned
|
||
|
||
### DNS redirect alone doesn't work for port 11001
|
||
- Added `dispatch.projecthelius.com`, `prod-game-ga.projecthelius.com`,
|
||
`a6e3077dcfb5ca02d.awsglobalaccelerator.com`, `a09484ac4d76eba25.awsglobalaccelerator.com`
|
||
to hosts file → 127.0.0.1
|
||
- Also tried DNS interception rules for `*.awsglobalaccelerator.com` and `*.projecthelius.com`
|
||
- **Result**: HTTP dispatch (18801) was redirected, but port 11001 was NOT
|
||
- **Reason**: The game server IP for 11001 is NOT resolved via DNS. It's either
|
||
hardcoded in the binary/pak or returned from a non-DNS source (possibly EOS,
|
||
or baked into `GameServerRegionAddress` / `RegionAddressMap` config)
|
||
- The `/get_notice` HTTP response contains NO IPs or server addresses
|
||
|
||
### Frida spawn mode doesn't work
|
||
- `frida.spawn([EXE_PATH])` launches the game but it needs Steam to authenticate
|
||
- Game launched via spawn can't connect to Steam → can't authenticate → useless
|
||
- **Solution**: Attach to running process instead
|
||
|
||
### Late Frida attach misses the handshake
|
||
- Game connects to port 11001 very early (during loading screen)
|
||
- By the time Frida attaches and hooks recv/send, the KEY_A/KEY_B handshake is already done
|
||
- All captured traffic is already encrypted post-handshake
|
||
|
||
### Hooking ChaCha20 scalar path catches nothing
|
||
- Hooked at RVA 0xc25118 (scalar ChaCha20 entry) → 0 calls
|
||
- **Reason**: Modern CPU has AVX, so the AVX path at 0xc254d4 is used instead
|
||
- Also, 102 ChaCha20 states in heap are mostly from OpenSSL TLS, not game server
|
||
|
||
### PyCryptodome cannot reproduce game's ChaCha20 keystream
|
||
- Captured raw key (32B) from `[this+0x68]` and nonce (12B) from `[this+0x78]`
|
||
- `ChaCha20.new(key=key, nonce=nonce)` produces different keystream
|
||
- Tried all combinations: 8B nonce, 12B nonce, reversed, different offsets
|
||
- **Reason**: OpenSSL's internal ChaCha20 key schedule transforms the key before
|
||
storing it in the EVP cipher context. The block function receives pre-processed
|
||
state (a2 arg is all zeros, actual key material is embedded differently).
|
||
- **Fix**: Capture keystream via XOR (ciphertext ⊕ plaintext) instead of reproducing it
|
||
|
||
### Hooking ChaCha20 block function args are misleading
|
||
- `sub_140C250C0(a1, a2, a3, a4, a5)` from IDA:
|
||
- `a2` (rdx) = all zeros (not the key!)
|
||
- `a3` (r8) = 64 (not data length - possibly rounds or block size)
|
||
- `a4` (r9) = 16-byte value (counter+nonce combined)
|
||
- The state at rcx[0:32] is NOT the raw key but pre-processed OpenSSL state
|
||
- **Lesson**: Don't assume standard ChaCha20 state layout when hooking OpenSSL internals
|
||
|
||
### Port TIME_WAIT blocks proxy restart on Windows
|
||
- After game disconnects, port 11001 stays in TIME_WAIT for 30-120 seconds
|
||
- Python's `asyncio.start_server` with `reuse_address=True` gets EACCES (10013) on Windows
|
||
- **Fix**: Wait for TIME_WAIT to expire, or use `SO_REUSEADDR` at socket level
|
||
|
||
### What DOES work: Frida connect() hook + TCP proxy
|
||
- Hook `ws2_32!connect()` in the game process
|
||
- When destination port == 11001, rewrite the IP bytes in the sockaddr_in struct to 127.0.0.1
|
||
- TCP proxy on 127.0.0.1:11001 forwards to real server and logs everything
|
||
- **Successfully captured full KEY_A/KEY_B handshake**
|
||
|
||
## Running the MITM Proxy (step by step)
|
||
|
||
```bash
|
||
PYTHON="X:/Users/user/AppData/Local/Programs/Python/Python313/python.exe"
|
||
|
||
# 1. Add to hosts file (for HTTP dispatch on 18801):
|
||
# 127.0.0.1 dispatch.projecthelius.com
|
||
|
||
# 2. Start TCP proxy (must bind before game connects):
|
||
$PYTHON -u frida_hooks/tcp_proxy_decrypt.py
|
||
|
||
# 3. Launch the game via Steam
|
||
|
||
# 4. Attach Frida redirect (in separate terminal):
|
||
$PYTHON -u frida_hooks/redirect_and_capture.py
|
||
|
||
# 5. Attach Frida key/plaintext capture (in separate terminal):
|
||
$PYTHON -u frida_hooks/run_key_capture.py
|
||
|
||
# 6. Connect to a server in-game
|
||
# → Frida rewrites connect(11001) destination to 127.0.0.1
|
||
# → Proxy captures KEY_A/KEY_B handshake + all encrypted traffic
|
||
# → Key capture hook captures plaintext + keystream via XOR
|
||
# → Captures saved to frida_hooks/captures/
|
||
```
|
||
|
||
## Running Plaintext Capture Only (no proxy needed)
|
||
|
||
```bash
|
||
PYTHON="X:/Users/user/AppData/Local/Programs/Python/Python313/python.exe"
|
||
|
||
# 1. Launch the game via Steam and connect to server
|
||
|
||
# 2. Attach Frida plaintext capture:
|
||
$PYTHON -u frida_hooks/run_key_capture.py
|
||
|
||
# This hooks the game's encrypt/decrypt wrapper and shows all
|
||
# plaintext protobuf messages in real time. No proxy needed.
|
||
```
|
||
|
||
## PE Section Layout
|
||
|
||
Binary has 14 sections. Notable:
|
||
```
|
||
.rsrc: VA=0x1000 size=0x7431000 prot=xr (CODE - contains ChaCha20 impl!)
|
||
.xtls: VA=0x7432000 size=0x1ffe000 prot=r
|
||
.trace: VA=0x9430000 size=0x5b9000 prot=rw
|
||
.data1: VA=0xa2bd000 size=0xa605544 prot=xrw (also executable)
|
||
```
|
||
ChaCha20 code at RVA 0xc25161 is in `.rsrc` (executable section).
|
||
|
||
## ChaCha20 Implementation Details (Updated with IDA + Frida analysis)
|
||
|
||
### Architecture: OpenSSL EVP API
|
||
|
||
The game uses **OpenSSL's EVP interface** for ChaCha20, NOT a custom implementation.
|
||
Confirmed by IDA decompilation showing `"crypto\\evp\\evp_enc.c"` strings.
|
||
|
||
| IDA VA | RVA | Role |
|
||
|--------|-----|------|
|
||
| `0x140C250C0` | `0xC250C0` | ChaCha20 block generator (low-level, generates keystream) |
|
||
| `0x140C250E8` | `0xC250E8` | Mid-function: CPU feature check (AVX vs scalar) |
|
||
| `0x140C25118` | `0xC25118` | Scalar path entry (never called on modern CPUs) |
|
||
| `0x140C254D4` | `0xC254D4` | AVX path entry (used on modern CPUs) |
|
||
| `0x146F332E0` | `0x6F332E0` | `EVP_EncryptUpdate(ctx, out, outl, in, inl)` |
|
||
| `0x146F332B0` | `0x6F332B0` | `EVP_CipherInit_ex` wrapper |
|
||
| `0x1449A2EB0` | `0x49A2EB0` | **Game's encrypt/decrypt wrapper** (key function!) |
|
||
|
||
### Game Encrypt/Decrypt Wrapper (RVA 0x49A2EB0)
|
||
|
||
This is the main encrypt/decrypt function called by the network code.
|
||
|
||
**Calling convention** (Windows x64):
|
||
- `rcx` = `this` pointer (game cipher context object)
|
||
- `r8d` = data length
|
||
- `r9` = data buffer pointer (in-place encrypt/decrypt)
|
||
- `rdx` = secondary buffer (?)
|
||
- `[rbp+0x30+arg_20]` = output pointer for processed length
|
||
|
||
**Game cipher context object layout** (at `this`):
|
||
| Offset | Type | Contents |
|
||
|--------|------|----------|
|
||
| `+0x60` | byte | Encrypt flag (0=decrypt/recv, 1=encrypt/send) |
|
||
| `+0x68` | ptr | Pointer to 32-byte key |
|
||
| `+0x78` | ptr | Pointer to 12-byte nonce |
|
||
| `+0x90` | ptr | EVP_CIPHER_CTX pointer |
|
||
| `+0xA0` | uint64 | Stream byte offset (cumulative) |
|
||
|
||
**What the function does** (per IDA decompilation):
|
||
1. Reads stream byte offset from `[this+0xA0]`, divides by 64 to get block counter
|
||
2. Builds 16-byte IV: `[4B block_counter_LE][12B nonce_from_this+0x78]`
|
||
3. Calls `EVP_CipherInit_ex` with the IV (re-initializes cipher for each chunk)
|
||
4. Calls `EVP_EncryptUpdate` to process the data in-place
|
||
5. Updates stream offset: `[this+0xA0] += data_length`
|
||
|
||
### Encryption is a Continuous Stream
|
||
|
||
Despite re-initializing EVP per chunk, the block counter ensures continuity.
|
||
The counter progression matches a continuous ChaCha20 stream:
|
||
```
|
||
offset=0 → blk=0, len=2 (first packet fragment)
|
||
offset=2 → blk=0, len=5
|
||
offset=7 → blk=0, len=22
|
||
offset=29 → blk=0, len=2
|
||
offset=31 → blk=0, len=7
|
||
offset=38 → blk=0, len=42
|
||
offset=80 → blk=1, len=2 (crossed 64-byte block boundary)
|
||
offset=88 → blk=1, len=538
|
||
offset=626 → blk=9, len=2
|
||
offset=643 → blk=10, len=1171
|
||
```
|
||
|
||
Both directions (C→S and S→C) appear to use the **same key and nonce**
|
||
with a **single shared stream offset counter**.
|
||
|
||
### PyCryptodome Incompatibility
|
||
|
||
The raw key from `[this+0x68]` and nonce from `[this+0x78]` do NOT produce
|
||
matching keystream when used with PyCryptodome's `ChaCha20.new(key, nonce)`.
|
||
The internal ChaCha20 state at the block function entry also does not match
|
||
standard layout (no sigma constants visible; `a2` arg is all zeros).
|
||
|
||
This is likely because OpenSSL's internal ChaCha20 key schedule transforms
|
||
the key before storing it, and the block function receives pre-processed state.
|
||
|
||
### Working Approach: Keystream Capture via XOR
|
||
|
||
Since we cannot reproduce the keystream with PyCryptodome, we capture it directly:
|
||
1. Hook the game wrapper at RVA `0x49A2EB0`
|
||
2. Read data buffer before call (ciphertext) and after call (plaintext)
|
||
3. XOR ciphertext ⊕ plaintext = keystream at that stream offset
|
||
4. Save keystream to `captures/keystream.bin` for proxy use
|
||
|
||
Verified: keystream is consistent and deterministic within a session.
|
||
|
||
### Confirmed Decrypted Traffic Samples
|
||
|
||
First packets after KEY_A/KEY_B handshake:
|
||
```
|
||
offset=7, 22B plaintext: 0801100120ffffffff0f420a31373735373133313230
|
||
→ protobuf: field1=1(ROOM), field2=1, field4=0xFFFFFFFF, field8="1775713120"(timestamp)
|
||
|
||
offset=38, 42B plaintext: 080110...1a0b4c6f63616c526567696f6e...5a074d524c4f4b4f50900103
|
||
→ "LocalRegion", "MRLOKOP" (player name)
|
||
|
||
offset=88, 538B: RoleListFullS2C or similar - contains character data
|
||
→ "Alet" (character name), favor/unlock data
|
||
|
||
offset=643, 1171B: Large data dump with character details
|
||
→ "Alet", "Celia" - character names with stats
|
||
```
|
||
|
||
## Protobuf Schema Extraction Method
|
||
|
||
Extracted at runtime using Frida by:
|
||
1. Scanning for `"ParalogueNet"` package declaration pattern `12 0c 50 61 72 61 6c 6f 67 75 65 4e 65 74`
|
||
2. Found 4 FileDescriptorProto blobs (one per .proto file)
|
||
3. Each blob starts with `0a <len> <filename>.proto 12 0c ParalogueNet`
|
||
4. Raw blobs fail `descriptor_pb2.FileDescriptorProto.ParseFromString()` due to imports
|
||
5. **Fix**: Strip field 3 (dependency) keeping only fields {1,2,4,5,12} (name, package, message_type, enum_type, syntax)
|
||
6. Parsed successfully: 239 messages, 24 enums across 4 files
|
||
|
||
Files extracted:
|
||
| Proto File | Messages | Enums | RVA |
|
||
|-----------|----------|-------|-----|
|
||
| common.proto | 43 | 11 | 0x80fd870 |
|
||
| enum.proto | 0 | 12 | 0x8105dd0 |
|
||
| player.proto | 155 | 1 | 0x810ef00 |
|
||
| ueroom.proto | 41 | 0 | 0x8117f70 |
|
||
|
||
Full schema saved to `frida_hooks/paralogue_net_full.proto` (1704 lines).
|
||
|
||
## Critical Protobuf Messages (from extracted schema)
|
||
|
||
```protobuf
|
||
message VerifyLoginTokenRsp {
|
||
StatusCode status = 1;
|
||
uint32 user_id = 2;
|
||
uint32 account_type = 3;
|
||
string login_token = 4;
|
||
uint32 reconnect_seed = 5;
|
||
bytes chacha20_key = 18; // ← SESSION ENCRYPTION KEY
|
||
bytes chacha20_iv = 19; // ← SESSION ENCRYPTION IV
|
||
}
|
||
|
||
message UePlayerLoginRsp {
|
||
StatusCode status = 1;
|
||
string name = 2;
|
||
int64 received_total_like_count = 3;
|
||
uint32 player_id = 4;
|
||
map<uint32, int64> recognition = 5; // ← PATREON/VIP TIERS
|
||
}
|
||
|
||
message RoleListFullS2C {
|
||
StatusCode status = 1;
|
||
PlayerRoles role_list = 2; // contains RoleCell array with is_unlock
|
||
}
|
||
|
||
message PlayerLoginRsp {
|
||
StatusCode status = 1;
|
||
int64 server_time_ms = 2;
|
||
string region_name = 3;
|
||
ServerType server_type = 18;
|
||
}
|
||
|
||
// MsgType enum values confirmed from capture:
|
||
// MsgType_KEY_A = 1 (value in envelope field 2 = 1001 decimal... wait)
|
||
```
|
||
|
||
**Note on MsgType values**: The enum defines KEY_A=1, KEY_B=2, but in the wire
|
||
envelope field 2 we see values 1001 and 1002. This means field 2 is NOT the
|
||
MsgType enum directly - it's a msg_id that maps to message types differently.
|
||
1001 = handshake request, 1002 = handshake response. The MsgType enum may be
|
||
used differently internally.
|
||
|
||
---
|
||
|
||
## Session Log: 2026-04-15 — MITM Tooling + Key Extraction
|
||
|
||
### What was built
|
||
|
||
**`frida_hooks/paralogue_decoder.py`** — shared library
|
||
|
||
Framing + 239-type msg_id identification. Used by both the in-process decoder
|
||
and the proxy.
|
||
|
||
- `Stream` with `drain_stream()`: strict `[2B BE prefix N][N-byte PacketHead][body_len bytes body]` framing. `body_len` is body-only.
|
||
- `identify_body()`: parses body against every type in `paralogue_net_full_pb2`, scores by field count, canonical-round-trip, UTF-8 string validity, and packed-int-as-ASCII penalty.
|
||
- `known_msg_ids.json`: user-editable hint file auto-promoted with high-confidence (score ≥ 60) mappings.
|
||
|
||
**`frida_hooks/protocol_decoder.js`** — Frida hooks
|
||
|
||
- `DECRYPT_RVA = 0x49A2EB0` — attaches onEnter/onLeave. Reads plaintext from `r9` onLeave and emits `{t:'chunk', source:'recv', ...}` to Python.
|
||
- `SEND_RVA = 0x49CEA90` — attaches onEnter. Reads the fully-assembled pre-encrypt plaintext buffer at `*(rdx)` with length `r9d`. Emits `{t:'chunk', source:'send', ...}`.
|
||
- `maybeEmitKey()` — on every wrapper call, reads the active ChaCha20 key/nonce/counter from the cipher context's this-pointer and emits `{t:'session_key', this_id, flag, offset, key_hex, nonce_hex}` whenever the key bytes change. The game pools cipher-context pointers across reconnects, so we key by `(this_id, key_hex)` to catch key rotations.
|
||
|
||
**`frida_hooks/paralogue_mitm.py`** — merged tool
|
||
|
||
Single asyncio process that:
|
||
1. Runs the TCP proxy on 11001 + 18801.
|
||
2. Attaches Frida: loads `redirect_connect.js` + `protocol_decoder.js` against the running `Paralogue-Win64-Shipping.exe`.
|
||
3. Marshals plaintext chunks from Frida into the same event loop, reassembles streams per `(this_id, enc)`, runs `drain_stream`, identifies each body via `paralogue_decoder`, and writes JSONL.
|
||
|
||
Outputs per session:
|
||
- `captures/mitm_<ts>_decoded.jsonl` — structured decoded messages (seq, direction, msg_id, msg_type, body_len, fields dict, top candidates).
|
||
- `captures/mitm_<ts>_wire.jsonl` — raw encrypted wire traffic (both directions, ciphertext).
|
||
- `captures/mitm_<ts>_chunks.jsonl` — raw plaintext chunks from the Frida hook.
|
||
- `captures/current_session_key.json` — every distinct cipher-context key/nonce seen.
|
||
|
||
**`frida_hooks/run_decoder.py`** — standalone decoder (no proxy)
|
||
|
||
### Framing: confirmed
|
||
|
||
Every logical message is three calls into the cipher wrapper, in order:
|
||
|
||
1. `[2B BE prefix]` — value `N` (the PacketHead length, 5–9 bytes typical).
|
||
2. `[N-byte PacketHead]` — protobuf with `packet_id`, `msg_id`, `body_len` etc.
|
||
3. `[body_len bytes body]` — the actual message body.
|
||
|
||
All three arrive on the same stream key `(this_id, enc_flag)` with consecutive `[this+0xA0]` offsets. Reassembly is by offset insertion into a per-stream bytearray, then greedy `drain_stream`.
|
||
|
||
### ChaCha20 — what actually works
|
||
|
||
Earlier RESEARCH.md claimed PyCryptodome couldn't reproduce the game's keystream. **Python's `cryptography` library (OpenSSL-backed) works.** Verified live: the key read from `[this+0x68]` and nonce from `[this+0x78]` of the send-side cipher context, fed to
|
||
`Cipher(ChaCha20(key, struct.pack('<I', block) + nonce), mode=None)` with block = `offset // 64` and `skip = offset % 64` bytes advanced, produces plaintext that matches the game exactly. First post-handshake C->S packet decrypted to `00 05 08 02 10 eb 07` — clean protobuf prefix + PacketHead.
|
||
|
||
### Cipher context struct
|
||
|
||
```
|
||
offset type field
|
||
+0x60 u8 direction flag (empirically always 1 for the hook we see)
|
||
+0x68 ptr -> 32B ChaCha20 key
|
||
+0x78 ptr -> 12B ChaCha20 nonce
|
||
+0x88 ptr alt EVP ctx ptr (seen in sub_1449A52C0 send helper)
|
||
+0x90 ptr EVP_CIPHER_CTX pointer (seen in 0x49A2EB0 wrapper)
|
||
+0x98 u64 alt stream offset (sub_1449A52C0)
|
||
+0xA0 u64 stream byte offset — advances by bytes processed on each call
|
||
```
|
||
|
||
The two different offset-pairs (+0x88/+0x98 vs +0x90/+0xA0) suggest there are
|
||
two related cipher contexts with slightly different layouts, one for encrypt
|
||
and one for decrypt. **Important**: our current hook at 0x49A2EB0 captures the
|
||
**C->S encrypt** cipher context. S->C decrypt uses a separate context we have
|
||
not yet located.
|
||
|
||
### Key rotation across reconnects
|
||
|
||
Observed: the game reuses `this` pointers for cipher contexts across
|
||
reconnects, but the key/nonce bytes at `[this+0x68]`/`[this+0x78]` change on
|
||
each new session. Dedupe by `(this_id, key_hex)` — not by `this_id` alone.
|
||
|
||
### Direction flag
|
||
|
||
`[this+0x60]` — documented as 0=decrypt/1=encrypt, but empirically we only
|
||
ever observe 1 on the contexts we've captured. The decrypt wrapper for S->C
|
||
likely lives at a different address; it doesn't appear to come through
|
||
0x49A2EB0. S->C plaintext still reaches Python via chunks because 0x49A2EB0's
|
||
onLeave buffer contains post-decrypt bytes for some code paths — so the same
|
||
wrapper is called for both directions, but key-read via offsets we currently
|
||
use only returns the encrypt-side key.
|
||
|
||
### Decoded traffic highlights
|
||
|
||
Confirmed message-type mappings learned from live sessions (now in
|
||
`known_msg_ids.json`):
|
||
|
||
```
|
||
1004 PlayerLoginRsp
|
||
1006 PlayerLoginRsp (alt? observed)
|
||
1007 KickPlayerS2C (low confidence — wire-compatible with others)
|
||
1008 PlayerPingRsp
|
||
1038 AchievementFullS2C
|
||
1094 UePlayerLoginRsp
|
||
1200 ClothesPresetUpdateS2C
|
||
1206 BattlePassInfo
|
||
1230 CharacterShoot
|
||
1231 BpExpChangeS2C
|
||
1238 VerifyLoginTokenExtS2C
|
||
```
|
||
|
||
### Gotchas worth writing down
|
||
|
||
- **Frida attach target must be the live PID.** If the game crashes or the
|
||
user restarts it, the PID changes and our tool's old Frida session is
|
||
orphaned.
|
||
- **`Module.findExportByName` is flaky on Windows.** Use `mod.enumerateExports()`.
|
||
- **`NativeFunction` on x64 must not specify ABI.** Omit the third argument.
|
||
- **TCP TIME_WAIT blocks proxy restart on Windows** for 30–120 seconds.
|
||
`reuse_address=True` works. Don't hammer-restart.
|
||
- **cryptography's `ChaCha20` takes a 16-byte nonce** = 4B little-endian
|
||
block counter + 12B nonce. To start at an arbitrary stream offset, split
|
||
into `block = offset // 64` and skip `offset % 64` bytes of leading
|
||
keystream output before the actual ciphertext.
|
||
- **The wrapper is called 3×/msg on decrypt path (prefix, header, body)
|
||
but 1×/msg on encrypt path** (the send helper passes the fully-assembled
|
||
buffer to the cipher in one shot).
|
||
- **Msg-id identification has inherent ambiguity.** Many types share wire
|
||
layouts (e.g. field 1 varint + field 3 LEN). The identifier scores top-3
|
||
candidates; the winner is only reliable when cached in `known_msg_ids.json`
|
||
from a confirmed sighting.
|
||
|
||
---
|
||
|
||
## Session 2026-04-15 (continued) — bidirectional wire rewriting, dispatch-table extraction, and the experiments hunt
|
||
|
||
### Summary of what worked
|
||
|
||
By the end of the session the proxy is a closed-loop wire rewriter:
|
||
|
||
* **Bidirectional decrypt** of S->C and C->S using the captured ChaCha20
|
||
key, with proxy-side counter sync.
|
||
* **Frame-aware S->C rewriter** that decrypts incoming wire bytes, parses
|
||
protobuf frames, runs them through a modify callback, re-encrypts at a
|
||
proxy-tracked counter, and forwards. ChaCha20's involution property
|
||
(encrypt(decrypt(x,k,n,c), k,n,c) == x) makes identity transforms a
|
||
no-op on the wire — essential for stability.
|
||
* **Ground-truth dispatch table dump** from the game's internal
|
||
`msg_id -> factory` hash map.
|
||
* **Strict protobuf identifier** that resolves type ambiguity by demanding
|
||
zero unknown fields after parse + ASCII-run sanity + direction-suffix
|
||
preference.
|
||
* **Live, end-to-end client-side modification** of `BagItemFullS2C`,
|
||
`RoleListFullS2C`, `PlayerMainDataRsp`, and `CardBagOpenRsp` —
|
||
visible in-game (affection bumps, item count change, +2000 cards
|
||
granted on a single blueprint open).
|
||
|
||
### IDA finding: cipher state is per-direction within one socket
|
||
|
||
Disassembly of `sub_1449A2EB0` (decrypt, S->C wrapper) and
|
||
`sub_1449A52C0` (encrypt, C->S wrapper) shows both functions read from
|
||
the **same `this`** pointer with the **same key/nonce offsets**:
|
||
|
||
```
|
||
+0x60 uint8 encryption-enabled flag
|
||
+0x68 void* 32B ChaCha20 key (shared both directions)
|
||
+0x78 void* 12B ChaCha20 nonce (shared both directions)
|
||
+0x88 void* encrypt EVP context (C->S only)
|
||
+0x90 void* decrypt EVP context (S->C only)
|
||
+0x98 uint64 encrypt byte counter (C->S)
|
||
+0xA0 uint64 decrypt byte counter (S->C)
|
||
```
|
||
|
||
Practical consequence: **one captured key serves both directions**.
|
||
The previous note in NEXT_STEPS.md ("S->C key lives in a different
|
||
context") was wrong — the previous failure was a stale stream-offset
|
||
assumption, not a missing key.
|
||
|
||
### Bidirectional wire decryption in the proxy
|
||
|
||
Implemented in `paralogue_decoder.py` and `paralogue_mitm.py` as
|
||
`WireCipher` (single-direction stream cipher with byte-offset seek)
|
||
plus per-direction state on `Session`:
|
||
|
||
```python
|
||
class WireCipher:
|
||
def __init__(self, key, nonce12, start_offset=0): ...
|
||
def decrypt(self, data: bytes) -> bytes: ... # advances .offset
|
||
encrypt = decrypt # ChaCha20 is symmetric
|
||
```
|
||
|
||
The handshake packet (`msg_id 1002 VerifyLoginTokenRsp`, S->C) is a
|
||
mixed plaintext/ciphertext frame: the first ~266 bytes are a plaintext
|
||
RSA-protected exchange, and the remaining ~29 bytes are the *first*
|
||
ChaCha20-encrypted frame (typically `VerifyLoginTokenExtS2C` at offset
|
||
0). The proxy splits the handshake at `2 + prefix + body_len` and
|
||
treats only the trailing bytes as encrypted.
|
||
|
||
Counter handling: when the proxy sees encrypted bytes **before** the
|
||
key arrives via Frida (timing race — the key only becomes readable
|
||
after the client processes its first decrypt, which itself fires the
|
||
hook), the proxy forwards those bytes untouched and counts them as
|
||
`passthrough_enc_bytes`. When the key finally arrives, both the in
|
||
and out ciphers are initialized at offset = `passthrough_enc_bytes`,
|
||
so the proxy and client decrypt counters stay aligned.
|
||
|
||
### `WireRewriter` — frame-aware S->C modification
|
||
|
||
```python
|
||
class WireRewriter:
|
||
cipher_in : WireCipher # decrypts wire-from-server
|
||
cipher_out : WireCipher # encrypts wire-to-client (independent counter)
|
||
plain_buf : bytearray # decrypted bytes awaiting frame completion
|
||
modify_cb : (msg_id, head, body) -> bytes | None
|
||
|
||
def process(self, server_bytes) -> client_bytes_to_forward
|
||
```
|
||
|
||
Loop per direction:
|
||
1. Decrypt arriving server bytes into `plain_buf`.
|
||
2. Drain complete frames `[2B prefix][N-byte head][body_len bytes body]`.
|
||
3. For each frame, call `modify_cb(msg_id, head, body)`. If it returns
|
||
new bytes: patch `head.body_len` to the new size, rebuild the head,
|
||
rebuild the prefix.
|
||
4. Re-encrypt the (possibly-modified) plaintext stream through
|
||
`cipher_out` and emit.
|
||
|
||
If `modify_cb` always returns `None`, output bytes are byte-identical
|
||
to input (XOR involution) — the rewriter behaves as a passthrough.
|
||
|
||
Critical bug found and fixed mid-session: rewriter state is **per
|
||
TCP connection**, not per session. The game reconnects on logout and
|
||
the new handshake bytes were being treated as post-handshake
|
||
encrypted data by the still-`handshake_done=True` rewriter. This
|
||
silently passed through unchanged (involution again) but the modify
|
||
callback never fired. Fix: `handle_game_client` instantiates a fresh
|
||
`WireRewriter` (preserving the modify callback) on every new
|
||
inbound connection.
|
||
|
||
### Dispatch-table dump
|
||
|
||
`sub_1449BD0F0` (packet reader) hash-looks up the msg_id against:
|
||
|
||
```
|
||
qword_1498F2D50 // bucket array base (entries are 32 bytes each)
|
||
dword_1498F2D58 // count of live entries
|
||
qword_1498F2D90 // index array (int32[], or &unk_1498F2D88 inline if not allocated)
|
||
dword_1498F2D98 // hash size = pow2 mask + 1
|
||
```
|
||
|
||
Entry layout (recovered by reading raw bytes via Frida):
|
||
|
||
```
|
||
+0 uint32 msg_id
|
||
+4 uint32 hash/tag
|
||
+8 void* factory_ptr (heap, moves between runs)
|
||
+16 void* secondary obj (= factory - 0x10, semantically unclear)
|
||
+24 int32 next_idx (chain)
|
||
+28 uint32 padding
|
||
```
|
||
|
||
`dispatch_dump.js` walks the hash chain, reads each entry, and emits
|
||
`(msg_id, factory_ptr, vtbl)`. The factory pointer is heap-allocated
|
||
and *not stable across runs* (~0x100 jitter), but the **vtable** that
|
||
factory points to lives in `.rdata` — and the game binary has no
|
||
ASLR for the main exe (`module_base == 0x140000000` always) — so
|
||
**vtables are stable across runs** and serve as the canonical class
|
||
identifier.
|
||
|
||
`Session` keys `factory_to_type.json` by vtable address:
|
||
|
||
```
|
||
"0x148106f48": "VerifyLoginTokenExtS2C",
|
||
"0x14810a610": "RoleListFullS2C",
|
||
"0x14810a960": "BagItemFullS2C",
|
||
...
|
||
```
|
||
|
||
This file is loaded at startup so previously-pinned types are
|
||
recognized immediately without re-learning.
|
||
|
||
### Strict identifier with three rejection rules
|
||
|
||
`identify_body_strict(body)` parses the body against every type in
|
||
the schema and keeps only candidates that:
|
||
|
||
1. **Length match** — `len(SerializeToString()) == len(body)`.
|
||
2. **No unknown fields** — `SerializeToString()` before and after
|
||
`DiscardUnknownFields()` must be byte-identical (otherwise some
|
||
bytes were absorbed into unknown-field storage, meaning the
|
||
schema doesn't actually describe this body).
|
||
3. **No packed-int-as-ASCII string** — if any `repeated <numeric>`
|
||
field has 5+ consecutive values in `[32, 126]`, the field is
|
||
probably a misparsed string. Common false-positive vector:
|
||
`[10, 7, 71, 97, 108, 97, 116, 101, 97, ...]` is the bytes for
|
||
`field 1 LEN, len 7, "Galatea"` decoded as `repeated uint32`.
|
||
|
||
When multiple candidates survive, the proxy applies a
|
||
**direction-aware tiebreaker**: prefer `*S2C` for S->C frames,
|
||
`*C2S`/`*Req` for C->S frames. If exactly one candidate matches the
|
||
suffix, pin it. This resolved `RoleListFullS2C` vs `ClothesColorCell`
|
||
(the long-standing misidentification of msg_id 1202).
|
||
|
||
Once a msg_id has a unique strict candidate, the rewriter pins
|
||
`vtbl -> type` permanently in `factory_to_type.json` and prefers that
|
||
mapping over any heuristic guess on subsequent decodes.
|
||
|
||
### Pinned mappings established this session
|
||
|
||
```
|
||
factory_to_type.json
|
||
0x148106f48 VerifyLoginTokenExtS2C
|
||
0x148109a08 UeGetRoomReq
|
||
0x14810a610 RoleListFullS2C
|
||
0x14810a960 BagItemFullS2C
|
||
0x14810d440 CommonShopBuyReq
|
||
0x14810edc8 BattlePassFullS2C
|
||
0x148113570 PlayerLoginReq
|
||
0x148113920 PlayerLoginRsp
|
||
0x148113ed0 PlayerMainDataRsp
|
||
0x148114330 PlayerTimeOffsetS2C
|
||
0x148114830 ShopUpdateFullS2C
|
||
```
|
||
|
||
Notable corrections from the heuristic cache:
|
||
|
||
| msg_id | old (heuristic) | new (strict) | size | content |
|
||
|---|---|---|---|---|
|
||
| 1006 | PlayerLoginRsp | **PlayerMainDataRsp** | 21B | player id/name/create_time |
|
||
| 1008 | PlayerPingRsp | **PlayerTimeOffsetS2C** | 16B | server clock sync |
|
||
| 1036 | AddTaskStepC2S | **BagItemFullS2C** | 1.2KB | inventory; clothes, currency, packs |
|
||
| 1094 | UePlayerLoginRsp | **BattlePassFullS2C** | 550B | active battle passes |
|
||
| 1182 | mis-id'd | **ShopUpdateFullS2C** | 345B | shop offers |
|
||
| 1192 | n/a | **CardBagOpenReq** | 4B | open blueprint |
|
||
| 1193 | n/a | **CardBagOpenRsp** | 28-49B | grant card_ids |
|
||
| 1202 | mis-id'd | **RoleListFullS2C** | 2KB | per-role data, full schema |
|
||
|
||
### Game UI taxonomy (from IDA strings)
|
||
|
||
```
|
||
EBagItemType : Normal | Pack | Cloth | Card | Gift | Money
|
||
EMenuBarType : Resume | Start | ChangeMap | Costume | Experiment
|
||
| Blueprint | Shop | ResearchPass | Settings
|
||
| Quit | RoundBattle
|
||
EShopType : Parts | Technology | Like | Pack | SexToy
|
||
| BoostPack | Outfit
|
||
EClothesSource: None | Default | BattlePass | AffinityLevel
|
||
| PartsShop | OutfitShop | SexToyShop
|
||
| BoostPackShop | Acheivement
|
||
EExperimentMoodType: None | Low | Mid | Max | ALL
|
||
```
|
||
|
||
Bag item-id ranges (observed in user's pre-injection state):
|
||
|
||
| prefix | count | num field | category |
|
||
|---|---|---|---|
|
||
| 0xxxx (2..574) | 66 | =1 | **experiments** (cards) |
|
||
| 11xxx | 8 | unset | **Pack / Blueprints** (lootbox items) |
|
||
| 2xxxx | 13 | =1 | unidentified (Card or Normal subtype) |
|
||
| 3xxxx | 44 | =1 | **Cloth** (confirmed via UI lighting up) |
|
||
| 4xxxx | 4 | =1 | unidentified |
|
||
| 99xxx | 16 | =N | **Money** (currencies) |
|
||
| 100001 | 1 | =1 | special singleton |
|
||
|
||
### Item-table walker
|
||
|
||
`sub_1449639C0(subsystem_ptr, item_id)` is the bag-item lookup. It
|
||
iterates a fixed array of 7 block descriptors at `subsystem+56..168`,
|
||
each `[ptr to records][int32 count][int32 padding]`. Each record is
|
||
120 bytes; the first 4 bytes are the item-id.
|
||
|
||
`item_table_dump.js` hooks the lookup, captures `rcx` (subsystem
|
||
pointer) on first natural call, then walks all blocks and emits every
|
||
known item-id. With our injection running, this dumped 14,181 unique
|
||
ids — but those are the bag's **runtime contents** (i.e., what we
|
||
injected + what the user originally had), **not the static
|
||
ItemTable** of all defined items. The static table that drives
|
||
client-side category filtering lives in a separate `UDataTable`
|
||
asset that we did not enumerate.
|
||
|
||
### Experiments — what they actually are
|
||
|
||
The Experiment menu (`EMenuBarType::Experiment`) tracks **cards** the
|
||
player has "learned". Server-side flow:
|
||
|
||
1. Player buys/owns a Blueprint (bag item in 11xxx range).
|
||
2. Player opens it: client sends `CardBagOpenReq{bag_ids=[N]}`
|
||
(`msg_id=1192`).
|
||
3. Server validates ownership; if rejected, sends `CardBagOpenRsp{
|
||
status=13, ...}`.
|
||
4. If accepted: server sends a small flurry —
|
||
`AchievementStepUpdateS2C` (achievement progress for opening
|
||
N-th blueprint), `RoleDilationUpdateS2C` (the *current* role's
|
||
dilation_exp gets a small bump), then
|
||
`CardBagOpenRsp{status=1, rets=[{card_id: K}, ...]}` carrying the
|
||
newly-granted card id(s). Duplicates still arrive as a single
|
||
`card_id`.
|
||
5. The client appends `K` to its **local** `learn_cards` collection
|
||
(persisted between sessions on disk; no full-state push from
|
||
server unless something forces a re-sync).
|
||
|
||
Storage of the experiment list is therefore:
|
||
|
||
* **Server-side:** authoritative, hidden from us — never sent over
|
||
the wire after the initial save-game load (no `LearnCardInfoFullS2C`
|
||
was observed in any session, even with non-zero learned cards).
|
||
* **Client-side:** local persistent state, updated incrementally by
|
||
`CardBagOpenRsp.rets`.
|
||
|
||
This is why `BagItemFullS2C` injection had no effect on the
|
||
Experiment UI: the UI doesn't read from the bag at all.
|
||
|
||
### What client-side persistence implies
|
||
|
||
`BagItemFullS2C` and the local card collection both **persist
|
||
across sessions** — the client treats the server's full-state push
|
||
as a *merge*, not a *replace*. Items added by injection in session N
|
||
are still in the client's local bag state in session N+1 even if
|
||
the server's authoritative push doesn't include them.
|
||
|
||
Practical consequences:
|
||
* Once we sprayed 14k items, the user's bag stayed polluted with
|
||
fake entries. The only clean reset is wiping the local save dir.
|
||
* Money values **do** get authoritatively updated (we saw `99991`
|
||
bump from 999999 back to 307 after re-login without the modifier).
|
||
So scalar fields are server-authoritative; **list membership is
|
||
client-additive only**.
|
||
|
||
### Modifiers we built
|
||
|
||
All in `paralogue_mitm.py`. Composed via a single `combined`
|
||
callback that tries each in order and returns the first non-`None`
|
||
result:
|
||
|
||
```
|
||
expand_card_bag_open_rsp_modifier # msg_id=1193 -> rets=0..2000
|
||
inject_unlock_functions_modifier # msg_id=1006 -> unlockFunctions=1..2000
|
||
inject_role_attrs_modifier # msg_id=1202 -> attrs[*]=999, is_unlock=True
|
||
inject_items_1_to_2000_modifier # msg_id=1036 -> items += dense ranges
|
||
```
|
||
|
||
The headline win: opening a single blueprint with
|
||
`expand_card_bag_open_rsp_modifier` active causes the proxy to
|
||
rewrite the server's `CardBagOpenRsp` to claim the player was
|
||
granted card ids `0..2000` in one go. The client appends every
|
||
returned `card_id` to its local `learn_cards` list, and the
|
||
Experiment UI lights up with every card whose id matches a real
|
||
entry in the client's static card DataTable. Out-of-range or
|
||
undefined card ids are silently filtered — no client crash, no UI
|
||
error.
|
||
|
||
### `--inject-items` is the single switch
|
||
|
||
`paralogue_mitm.py --inject-items` enables the rewriter with the
|
||
combined modifier chain. Without the flag, the proxy is a pure
|
||
passthrough — wire-decrypted for logging, but bytes forwarded to
|
||
the client are byte-identical to the server's.
|
||
|
||
### Files added or rewritten this session
|
||
|
||
| file | role |
|
||
|---|---|
|
||
| `frida_hooks/dispatch_dump.js` | walks msg_id->factory hash table at startup |
|
||
| `frida_hooks/item_table_dump.js` | walks bag-item subsystem records via runtime hook on `sub_1449639C0` |
|
||
| `frida_hooks/paralogue_mitm.py` | added `WireRewriter`, `WireCipher.encrypt`, four modifiers, per-connection rewriter reset, `--inject-items` flag |
|
||
| `frida_hooks/paralogue_decoder.py` | added `identify_body_strict` + `_has_packed_ascii_string` + ASCII-run heuristic |
|
||
| `frida_hooks/protocol_decoder.js` | emits both `offset_enc` (+0x98) and `offset_dec` (+0xA0) on session_key |
|
||
| `frida_hooks/factory_to_type.json` | persisted vtable -> protobuf class map (auto-loaded) |
|
||
| `frida_hooks/client_item_ids.json` | dumped runtime bag item ids (one snapshot) |
|
||
| `frida_hooks/run_mitm.bat` | one-shot kill-and-relaunch wrapper |
|
||
|
||
### Open questions left for next session
|
||
|
||
* The static **card DataTable** in the client (probably
|
||
`DT_CardTable` or similar UE asset) defines which card_ids are
|
||
valid for UI display. Walking that map would tell us how many
|
||
total experiments exist in the game and let us inject *only*
|
||
valid ids (no client filtering). Walking would be similar to
|
||
`item_table_dump.js` but targeting `UDataTable::FindRow` against
|
||
the card asset.
|
||
* `LearnCardInfoFullS2C` exists in the schema but was **never seen
|
||
in traffic** even with non-zero learned cards. Either the server
|
||
doesn't push it under any conditions we triggered, or it lives
|
||
behind an msg_id whose body strict-matches another type. 8
|
||
candidate FullS2C types remain unpinned.
|
||
* `Role.attrs` keys (3, 58-69, 72-74) saturated to 999 produced no
|
||
visible effect in the Experiment menu, ruling out per-role storage
|
||
for experiments. Still unclear what those attrs *do* drive.
|
||
* The Experiment UI count includes the user's locally-persisted
|
||
learn_cards even after a full re-login — confirming the client
|
||
uses on-disk save state as authoritative for that collection.
|
||
Server reconciliation point unknown.
|
||
|
||
### Reproducible quick-start
|
||
|
||
```
|
||
# In one terminal:
|
||
cd X:/Users/user/fallendoll
|
||
frida_hooks\run_mitm.bat --inject-items
|
||
|
||
# Launch the game via Steam after the proxy says "waiting for ..."
|
||
# Login, open a single blueprint -> entire experiment range unlocks
|
||
# in the client UI.
|
||
```
|