open-legacy-rpc 0.0.2__tar.gz

open_legacy_rpc-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Rose
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

open_legacy_rpc-0.0.2/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: open-legacy-rpc
+Version: 0.0.2
+Summary: Reverse-engineered wire format and implementation of Unity's legacy RPC networking (NetworkView / [RPC] / OnSerializeNetworkView)
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Rose-Vibe/open-legacy-rpc
+Project-URL: Documentation, https://github.com/Rose-Vibe/open-legacy-rpc/tree/main/docs
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff~=0.14; extra == "dev"
+Dynamic: license-file
+
+# open-legacy-rpc
+
+Reverse-engineered wire format spec and implementations (Python + TypeScript)
+of Unity's legacy RPC networking stack (`NetworkView` / `[RPC]` /
+`OnSerializeNetworkView`), last supported in Unity 2018.1.6f1. The transport
+layer is RakNet 3.731; this project documents and implements **Unity's
+undocumented framing on top of RakNet**.
+
+Unity is a trademark of Unity Technologies. This project is independent,
+clean-room reverse-engineered, and not affiliated with or endorsed by Unity
+Technologies.
+
+## Repository Structure
+
+```
+protocol/       Python reference implementation (client + server)
+ts/             TypeScript production implementation (client + server)
+experiments/    Unity projects for capture-based protocol analysis
+docs/research/  Wire format specifications
+docs/notes/     Lab notes and setup guides
+docs/plans/     Sprint plans (active and archived)
+```
+
+## Prerequisites
+
+- **Python**: 3.10+
+- **Node.js**: 18+ (TypeScript implementation)
+
+## Quick Start
+
+### Python
+
+```bash
+cd protocol
+pip install -e .          # or: pip install -r ../requirements-dev.txt
+python -m pytest ../tests/
+```
+
+### TypeScript
+
+```bash
+cd ts
+npm install
+npm test
+```
+
+## Wire Format Specs
+
+- [Unity Legacy Networking Wire Format](docs/research/unity-legacy-networking-wire-format.md)
+- [Master Server Wire Format](docs/research/master-server-wire-format.md)
+- [Spec Status](docs/research/spec-status.md)
+
+## Usage
+
+### TypeScript Server
+
+```typescript
+import { UnityServer, createUdpSocket } from 'open-legacy-rpc';
+
+const socket = createUdpSocket();
+const server = new UnityServer(socket, { port: 7777 });
+
+server.onConnect((session) => {
+  console.log(`Client connected: ${session.id}`);
+});
+
+server.onRpc('MyRpc', (session, ...params) => {
+  console.log('RPC received:', params);
+});
+
+await server.start();
+```
+
+### Python Client
+
+```python
+from protocol.unity_client import UnityClient
+
+client = UnityClient()
+client.connect('127.0.0.1', 7777)
+
+client.send_rpc('MyRpc', [42], view_id=1)
+
+for msg in client.poll(timeout=1.0):
+    print(msg)
+
+client.disconnect()
+```
+
+## PCAP Decoder
+
+Decode pcap/pcapng captures into structured JSON through the full protocol
+stack (RakNet → Unity → game-specific):
+
+```bash
+python3 tools/decode_pcap.py capture.pcap                       # all defaults
+python3 tools/decode_pcap.py capture.pcap --config config.json   # with config
+python3 tools/decode_pcap.py capture.pcap --compact              # single-line JSON
+```
+
+Config file (all fields optional):
+
+```json
+{
+  "serverPort": 7777,
+  "methodSignatures": { "RPC_TakeDamage": ["int", "float"] },
+  "viewNames": { "8192": "Player" }
+}
+```
+
+Output uses discriminated unions at each layer (`type` field). Game-specific
+data that can't be decoded is marked `{ "type": "not_deserialized", "rawHex": "..." }`
+for downstream post-processing.
+
+## Network Namespace
+
+Unity's RakNet crashes when the host has >10 IPv4 addresses. Use the
+included scripts to create an isolated network namespace:
+
+```bash
+sudo bash netns-setup.sh                          # create namespace
+sudo ip netns exec unitynet ./Player.x86_64 ...   # run Unity inside
+tshark -i veth-unet-h -f 'udp' -w /tmp/unity.pcap   # capture from host
+sudo bash netns-teardown.sh                        # clean up
+```
+
+## Shell Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `run-experiment.sh` | Run a Unity experiment with traffic capture |
+| `run-interop-tests.sh` | End-to-end interop tests: Python <-> Unity |
+| `run-server-only.sh` | Start a Unity server, wait for external connections |
+| `netns-setup.sh` | Create network namespace for Unity |
+| `netns-teardown.sh` | Tear down network namespace |

open_legacy_rpc-0.0.2/README.md

@@ -0,0 +1,135 @@
+# open-legacy-rpc
+
+Reverse-engineered wire format spec and implementations (Python + TypeScript)
+of Unity's legacy RPC networking stack (`NetworkView` / `[RPC]` /
+`OnSerializeNetworkView`), last supported in Unity 2018.1.6f1. The transport
+layer is RakNet 3.731; this project documents and implements **Unity's
+undocumented framing on top of RakNet**.
+
+Unity is a trademark of Unity Technologies. This project is independent,
+clean-room reverse-engineered, and not affiliated with or endorsed by Unity
+Technologies.
+
+## Repository Structure
+
+```
+protocol/       Python reference implementation (client + server)
+ts/             TypeScript production implementation (client + server)
+experiments/    Unity projects for capture-based protocol analysis
+docs/research/  Wire format specifications
+docs/notes/     Lab notes and setup guides
+docs/plans/     Sprint plans (active and archived)
+```
+
+## Prerequisites
+
+- **Python**: 3.10+
+- **Node.js**: 18+ (TypeScript implementation)
+
+## Quick Start
+
+### Python
+
+```bash
+cd protocol
+pip install -e .          # or: pip install -r ../requirements-dev.txt
+python -m pytest ../tests/
+```
+
+### TypeScript
+
+```bash
+cd ts
+npm install
+npm test
+```
+
+## Wire Format Specs
+
+- [Unity Legacy Networking Wire Format](docs/research/unity-legacy-networking-wire-format.md)
+- [Master Server Wire Format](docs/research/master-server-wire-format.md)
+- [Spec Status](docs/research/spec-status.md)
+
+## Usage
+
+### TypeScript Server
+
+```typescript
+import { UnityServer, createUdpSocket } from 'open-legacy-rpc';
+
+const socket = createUdpSocket();
+const server = new UnityServer(socket, { port: 7777 });
+
+server.onConnect((session) => {
+  console.log(`Client connected: ${session.id}`);
+});
+
+server.onRpc('MyRpc', (session, ...params) => {
+  console.log('RPC received:', params);
+});
+
+await server.start();
+```
+
+### Python Client
+
+```python
+from protocol.unity_client import UnityClient
+
+client = UnityClient()
+client.connect('127.0.0.1', 7777)
+
+client.send_rpc('MyRpc', [42], view_id=1)
+
+for msg in client.poll(timeout=1.0):
+    print(msg)
+
+client.disconnect()
+```
+
+## PCAP Decoder
+
+Decode pcap/pcapng captures into structured JSON through the full protocol
+stack (RakNet → Unity → game-specific):
+
+```bash
+python3 tools/decode_pcap.py capture.pcap                       # all defaults
+python3 tools/decode_pcap.py capture.pcap --config config.json   # with config
+python3 tools/decode_pcap.py capture.pcap --compact              # single-line JSON
+```
+
+Config file (all fields optional):
+
+```json
+{
+  "serverPort": 7777,
+  "methodSignatures": { "RPC_TakeDamage": ["int", "float"] },
+  "viewNames": { "8192": "Player" }
+}
+```
+
+Output uses discriminated unions at each layer (`type` field). Game-specific
+data that can't be decoded is marked `{ "type": "not_deserialized", "rawHex": "..." }`
+for downstream post-processing.
+
+## Network Namespace
+
+Unity's RakNet crashes when the host has >10 IPv4 addresses. Use the
+included scripts to create an isolated network namespace:
+
+```bash
+sudo bash netns-setup.sh                          # create namespace
+sudo ip netns exec unitynet ./Player.x86_64 ...   # run Unity inside
+tshark -i veth-unet-h -f 'udp' -w /tmp/unity.pcap   # capture from host
+sudo bash netns-teardown.sh                        # clean up
+```
+
+## Shell Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `run-experiment.sh` | Run a Unity experiment with traffic capture |
+| `run-interop-tests.sh` | End-to-end interop tests: Python <-> Unity |
+| `run-server-only.sh` | Start a Unity server, wait for external connections |
+| `netns-setup.sh` | Create network namespace for Unity |
+| `netns-teardown.sh` | Tear down network namespace |

open_legacy_rpc-0.0.2/open_legacy_rpc.egg-info/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: open-legacy-rpc
+Version: 0.0.2
+Summary: Reverse-engineered wire format and implementation of Unity's legacy RPC networking (NetworkView / [RPC] / OnSerializeNetworkView)
+License-Expression: MIT
+Project-URL: Repository, https://github.com/Rose-Vibe/open-legacy-rpc
+Project-URL: Documentation, https://github.com/Rose-Vibe/open-legacy-rpc/tree/main/docs
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff~=0.14; extra == "dev"
+Dynamic: license-file
+
+# open-legacy-rpc
+
+Reverse-engineered wire format spec and implementations (Python + TypeScript)
+of Unity's legacy RPC networking stack (`NetworkView` / `[RPC]` /
+`OnSerializeNetworkView`), last supported in Unity 2018.1.6f1. The transport
+layer is RakNet 3.731; this project documents and implements **Unity's
+undocumented framing on top of RakNet**.
+
+Unity is a trademark of Unity Technologies. This project is independent,
+clean-room reverse-engineered, and not affiliated with or endorsed by Unity
+Technologies.
+
+## Repository Structure
+
+```
+protocol/       Python reference implementation (client + server)
+ts/             TypeScript production implementation (client + server)
+experiments/    Unity projects for capture-based protocol analysis
+docs/research/  Wire format specifications
+docs/notes/     Lab notes and setup guides
+docs/plans/     Sprint plans (active and archived)
+```
+
+## Prerequisites
+
+- **Python**: 3.10+
+- **Node.js**: 18+ (TypeScript implementation)
+
+## Quick Start
+
+### Python
+
+```bash
+cd protocol
+pip install -e .          # or: pip install -r ../requirements-dev.txt
+python -m pytest ../tests/
+```
+
+### TypeScript
+
+```bash
+cd ts
+npm install
+npm test
+```
+
+## Wire Format Specs
+
+- [Unity Legacy Networking Wire Format](docs/research/unity-legacy-networking-wire-format.md)
+- [Master Server Wire Format](docs/research/master-server-wire-format.md)
+- [Spec Status](docs/research/spec-status.md)
+
+## Usage
+
+### TypeScript Server
+
+```typescript
+import { UnityServer, createUdpSocket } from 'open-legacy-rpc';
+
+const socket = createUdpSocket();
+const server = new UnityServer(socket, { port: 7777 });
+
+server.onConnect((session) => {
+  console.log(`Client connected: ${session.id}`);
+});
+
+server.onRpc('MyRpc', (session, ...params) => {
+  console.log('RPC received:', params);
+});
+
+await server.start();
+```
+
+### Python Client
+
+```python
+from protocol.unity_client import UnityClient
+
+client = UnityClient()
+client.connect('127.0.0.1', 7777)
+
+client.send_rpc('MyRpc', [42], view_id=1)
+
+for msg in client.poll(timeout=1.0):
+    print(msg)
+
+client.disconnect()
+```
+
+## PCAP Decoder
+
+Decode pcap/pcapng captures into structured JSON through the full protocol
+stack (RakNet → Unity → game-specific):
+
+```bash
+python3 tools/decode_pcap.py capture.pcap                       # all defaults
+python3 tools/decode_pcap.py capture.pcap --config config.json   # with config
+python3 tools/decode_pcap.py capture.pcap --compact              # single-line JSON
+```
+
+Config file (all fields optional):
+
+```json
+{
+  "serverPort": 7777,
+  "methodSignatures": { "RPC_TakeDamage": ["int", "float"] },
+  "viewNames": { "8192": "Player" }
+}
+```
+
+Output uses discriminated unions at each layer (`type` field). Game-specific
+data that can't be decoded is marked `{ "type": "not_deserialized", "rawHex": "..." }`
+for downstream post-processing.
+
+## Network Namespace
+
+Unity's RakNet crashes when the host has >10 IPv4 addresses. Use the
+included scripts to create an isolated network namespace:
+
+```bash
+sudo bash netns-setup.sh                          # create namespace
+sudo ip netns exec unitynet ./Player.x86_64 ...   # run Unity inside
+tshark -i veth-unet-h -f 'udp' -w /tmp/unity.pcap   # capture from host
+sudo bash netns-teardown.sh                        # clean up
+```
+
+## Shell Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `run-experiment.sh` | Run a Unity experiment with traffic capture |
+| `run-interop-tests.sh` | End-to-end interop tests: Python <-> Unity |
+| `run-server-only.sh` | Start a Unity server, wait for external connections |
+| `netns-setup.sh` | Create network namespace for Unity |
+| `netns-teardown.sh` | Tear down network namespace |

open_legacy_rpc-0.0.2/open_legacy_rpc.egg-info/SOURCES.txt

@@ -0,0 +1,39 @@
+LICENSE
+README.md
+pyproject.toml
+open_legacy_rpc.egg-info/PKG-INFO
+open_legacy_rpc.egg-info/SOURCES.txt
+open_legacy_rpc.egg-info/dependency_links.txt
+open_legacy_rpc.egg-info/requires.txt
+open_legacy_rpc.egg-info/top_level.txt
+protocol/__init__.py
+protocol/analyze_pcap.py
+protocol/bitstream.py
+protocol/diff_experiment.py
+protocol/huffman.py
+protocol/master_client.py
+protocol/master_serialization.py
+protocol/master_server.py
+protocol/pcap_reader.py
+protocol/raknet.py
+protocol/raknet_connection.py
+protocol/raknet_transport.py
+protocol/unity_client.py
+protocol/unity_protocol.py
+protocol/unity_rpc_decode.py
+protocol/unity_server.py
+tests/test_bitstream.py
+tests/test_cross_assembly_batch_index_dispatch.py
+tests/test_cross_conformance.py
+tests/test_decode_pcap.py
+tests/test_decode_safety.py
+tests/test_delta_state_sync.py
+tests/test_exception_safety.py
+tests/test_master_server.py
+tests/test_network_groups.py
+tests/test_python_integration.py
+tests/test_raknet_transport.py
+tests/test_unity_interop.py
+tests/test_unity_interop_server.py
+tests/test_unity_protocol.py
+tests/test_viewid_allocation.py

open_legacy_rpc-0.0.2/open_legacy_rpc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

open_legacy_rpc-0.0.2/open_legacy_rpc.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[dev]
+pytest
+ruff~=0.14

open_legacy_rpc-0.0.2/open_legacy_rpc.egg-info/top_level.txt

@@ -0,0 +1 @@
+protocol

open_legacy_rpc-0.0.2/protocol/analyze_pcap.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+Analyze pcap files from Unity legacy networking experiments.
+Dumps UDP payloads with hex + ASCII, identifies RakNet framing,
+and highlights potential Unity-layer messages.
+"""
+import struct
+import sys
+
+from .pcap_reader import read_pcap
+
+
+def hexdump(data, prefix='  '):
+    """Hex + ASCII dump."""
+    lines = []
+    for i in range(0, len(data), 16):
+        chunk = data[i:i+16]
+        hex_part = ' '.join(f'{b:02x}' for b in chunk)
+        ascii_part = ''.join(chr(b) if 32 <= b < 127 else '.' for b in chunk)
+        lines.append(f'{prefix}{i:04x}  {hex_part:<48s}  {ascii_part}')
+    return '\n'.join(lines)
+
+
+# RakNet offline message magic
+OFFLINE_MAGIC = bytes([
+    0x00, 0xFF, 0xFF, 0x00, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFD, 0xFD, 0xFD, 0xFD, 0x12, 0x34, 0x56, 0x78
+])
+
+
+def classify_packet(payload):
+    """Classify a UDP payload into RakNet packet types."""
+    if not payload:
+        return 'empty', {}
+
+    first = payload[0]
+
+    # Offline messages
+    if first == 0x05 and len(payload) > 17 and payload[1:17] == OFFLINE_MAGIC:
+        return 'open_connection_request', {'protocol_version': payload[17] if len(payload) > 17 else None}
+    if first == 0x06 and len(payload) > 17 and payload[1:17] == OFFLINE_MAGIC:
+        return 'open_connection_reply', {}
+    if first == 0x09 and len(payload) > 17:
+        return 'open_connection_request_2', {}
+
+    # Connected datagrams: check bitflags
+    # Bit 7 (MSB): is_ack
+    is_ack = (first >> 7) & 1
+    is_nak = (first >> 6) & 1 if not is_ack else 0
+
+    if is_ack:
+        return 'ack', {}
+    if is_nak:
+        return 'nak', {}
+
+    # Data datagram - try to parse encapsulated messages
+    return 'data', {'raw': payload}
+
+
+def find_known_patterns(payload, context=''):
+    """Look for known byte patterns in the payload."""
+    findings = []
+
+    # Look for float values we sent
+    for i in range(len(payload) - 3):
+        chunk = payload[i:i+4]
+
+        # Check for known int values (little-endian)
+        try:
+            val_le = struct.unpack('<i', chunk)[0]
+            val_be = struct.unpack('>i', chunk)[0]
+            if val_le in (0, 1, 42, -1, 2147483647, 10, 20, 30, 40, 99):
+                findings.append((i, f'int32_le={val_le}'))
+            if val_be in (0, 1, 42, -1, 2147483647, 10, 20, 30, 40, 99) and val_be != val_le:
+                findings.append((i, f'int32_be={val_be}'))
+        except struct.error:
+            pass
+
+        # Check for known float values (little-endian)
+        try:
+            fval_le = struct.unpack('<f', chunk)[0]
+            fval_be = struct.unpack('>f', chunk)[0]
+            for known in [1.0, 3.14159, -1.0, 2.0, 3.0, -100.5, 0.001, 999.999, 3.14, 45.0, 90.0, 180.0]:
+                if abs(fval_le - known) < 0.001:
+                    findings.append((i, f'float_le={fval_le:.6f}'))
+                if abs(fval_be - known) < 0.001 and abs(fval_be - fval_le) > 0.001:
+                    findings.append((i, f'float_be={fval_be:.6f}'))
+        except struct.error:
+            pass
+
+    # Look for known strings
+    for s in [b'Hello', b'Hello World', b'hello', b'A']:
+        idx = payload.find(s)
+        if idx >= 0:
+            findings.append((idx, f'string="{s.decode()}"'))
+
+    # Look for known byte patterns
+    idx = payload.find(b'\xDE\xAD\xBE\xEF')
+    if idx >= 0:
+        findings.append((idx, 'bytes=DEADBEEF'))
+
+    return findings
+
+
+def analyze_pcap(path):
+    """Full analysis of a pcap file."""
+    print(f'\n{"="*70}')
+    print(f'Analyzing: {path}')
+    print(f'{"="*70}\n')
+
+    server_port = 7777
+    packets = list(read_pcap(path))
+
+    for i, (ts, src_port, dst_port, payload) in enumerate(packets):
+        direction = 'C→S' if dst_port == server_port else 'S→C'
+        ptype, info = classify_packet(payload)
+
+        print(f'Packet {i+1}: {direction} ({src_port}→{dst_port}) {len(payload)}B  [{ptype}]')
+
+        # Show hex dump
+        print(hexdump(payload))
+
+        # Show any found patterns
+        findings = find_known_patterns(payload)
+        if findings:
+            print(f'  ** Found: {", ".join(f"@{off}: {desc}" for off, desc in findings)}')
+
+        print()
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print(f'Usage: {sys.argv[0]} <pcap-file> [pcap-file ...]')
+        sys.exit(1)
+
+    for path in sys.argv[1:]:
+        analyze_pcap(path)