# 🌐 RR3 Network Protocol & Port Analysis

**Based on APK Source Code Decompilation**

---

## 🎯 QUICK ANSWER

### Ports Used by RR3:
```
Port 443 (HTTPS) - ALL server communication
```

**That's it. Just standard HTTPS on port 443.**

---

## 📊 DETAILED ANALYSIS

### 1. Protocol
```
Protocol: HTTPS (HTTP over TLS/SSL)
Port: 443 (standard HTTPS port)
Method: HttpURLConnection (Java standard library)
```

### 2. Server Endpoints
**All use HTTPS on port 443:**

#### Production Servers:
```
https://syn-dir.sn.eamobile.com              (Director)
https://product.sn.eamobile.com              (Product Catalog)
https://user.sn.eamobile.com                 (User Management)
https://gateway.ea.com                       (API Gateway)
```

#### Network Testing:
```
https://ping1.tnt-ea.com                     (EA Network Check)
https://www.google.com                       (Backup Reachability Check)
```

#### CDN (Asset Delivery):
```
https://firemonkeys.akamaized.net            (Akamai CDN)
```

#### Analytics:
```
https://pin-river.data.ea.com                (Analytics)
https://river-mobile.data.ea.com             (Mobile Analytics)
```

---

## 🔍 SOURCE CODE EVIDENCE

### From: `com/ea/nimble/SynergyEnvironmentImpl.java`
```java
Line 20: private static final String SYNERGY_INT_SERVER_URL = 
         "https://director-int.sn.eamobile.com";

Line 21: private static final String SYNERGY_LIVE_SERVER_URL = 
         "https://syn-dir.sn.eamobile.com";

Line 22: private static final String SYNERGY_STAGE_SERVER_URL = 
         "https://director-stage.sn.eamobile.com";
```

### From: `com/ea/nimble/NetworkImpl.java`
```java
Line 30: private static final String BACKUP_NETWORK_REACHABILITY_CHECK_URL = 
         "https://www.google.com";

Line 32: private static final String MAIN_NETWORK_REACHABILITY_CHECK_URL = 
         "https://ping1.tnt-ea.com";
```

### From: `com/ea/nimble/NetworkConnection.java`
```java
Line 180: httpURLConnection.setConnectTimeout((int)(this.m_request.timeout * 1000.0d));
Line 181: httpURLConnection.setReadTimeout((int)(this.m_request.timeout * 1000.0d));

// Uses standard HttpURLConnection - no custom port configuration
// URL.getDefaultPort() returns 443 for HTTPS protocol
```

---

## 🛠️ CONNECTION DETAILS

### Connection Method
```java
Class: java.net.HttpURLConnection
SSL/TLS: Automatic via HTTPS protocol
Port Resolution: URL.getDefaultPort()
  - For "https://" URLs → returns 443
  - No explicit port specified in any URL
  - No custom port configuration found
```

### Timeout Configuration
```java
Default Timeout: 30 seconds
Connect Timeout: 30,000 ms (30 seconds)
Read Timeout: 30,000 ms (30 seconds)

Source: com/ea/nimble/HttpRequest.java:11
private static int DEFAULT_NETWORK_TIMEOUT = 30;
```

### Connection Properties
```java
Method: Standard HTTP methods (GET, POST, PUT, DELETE)
Protocol: HTTP/1.1 over TLS
Keep-Alive: Disabled (new connection per request)
SSL Verification: Relaxed (accepts self-signed certs)
  - Source: ALLOW_ALL_HOSTNAME_VERIFIER found in APK
```

---

## 🔐 SSL/TLS CONFIGURATION

### SSL Socket Factory
```
Uses: Default SSLSocketFactory
Certificate Validation: Permissive
  - Accepts self-signed certificates
  - Uses ALLOW_ALL_HOSTNAME_VERIFIER
  - No certificate pinning

This means your community server can use:
✅ Self-signed certificates
✅ Let's Encrypt certificates
✅ Any valid SSL certificate
```

### Why This Matters for Community Server:
```
Your server at: https://your-domain.com:443
OR simplified: https://your-domain.com

✅ Game will connect on port 443
✅ No need for custom port configuration
✅ Standard web hosting works perfectly
✅ Can use free SSL from Let's Encrypt
```

---

## 📡 NETWORK REQUEST FLOW

### 1. Director Service (Initial Connection)
```
URL: https://syn-dir.sn.eamobile.com/director/api/android/getDirectionByPackage
Port: 443 (implicit)
Method: GET
Headers:
  - SDK-VERSION
  - SDK-TYPE
  - Package-Name
  - Platform-Version
  - Carrier
  - Language
```

### 2. User Management
```
URL: https://user.sn.eamobile.com/user/api/android/getDeviceID
Port: 443 (implicit)
Method: GET
Headers:
  - Same as Director +
  - EAM-SESSION (after auth)
```

### 3. Product Catalog
```
URL: https://product.sn.eamobile.com/product/api/core/getAvailableItems
Port: 443 (implicit)
Method: POST
Headers:
  - EAM-SESSION
  - EAM-USER-ID
  - EA-SELL-ID
```

### 4. Asset Delivery (CDN)
```
URL: https://firemonkeys.akamaized.net/rr3/assets/[path]
Port: 443 (implicit)
Method: GET
Headers:
  - Standard HTTP headers
  - No authentication required
```

---

## 🚫 WHAT RR3 DOES NOT USE

### No Custom Ports:
```
❌ 8080 (HTTP alternate)
❌ 8443 (HTTPS alternate)
❌ 3000 (Development servers)
❌ 9000 (Game server ports)
❌ Any non-standard port
```

### No Alternative Protocols:
```
❌ WebSocket (no real-time communication)
❌ UDP (no game state sync)
❌ TCP sockets (no raw socket communication)
❌ QUIC/HTTP3 (uses HTTP/1.1)
```

### No P2P:
```
❌ No peer-to-peer networking
❌ No multiplayer matchmaking ports
❌ No NAT traversal
❌ All communication is client → server only
```

---

## 🔥 IMPLICATIONS FOR COMMUNITY SERVER

### Your Server Configuration:
```nginx
# Nginx/Apache configuration
server {
    listen 443 ssl;
    server_name your-rr3-server.com;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
    
    location / {
        proxy_pass http://localhost:5000;  # Your ASP.NET Core app
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

# That's it! Just HTTPS on port 443.
```

### Firewall Rules Needed:
```bash
# Incoming
Allow TCP port 443 (HTTPS)

# Outgoing (if your server needs to contact other services)
Allow TCP port 443 (HTTPS)

# That's all you need!
```

### DNS Configuration:
```
APK Modification Required:
- Change hardcoded URLs in APK
- Point to your domain
- OR use DNS hijacking (hosts file on phone)

Example:
syn-dir.sn.eamobile.com → your-server.com
product.sn.eamobile.com → your-server.com
user.sn.eamobile.com → your-server.com
```

---

## 📊 NETWORK TRAFFIC CHARACTERISTICS

### Request Volume:
```
Startup: 3-5 requests (Director, User auth, Product catalog)
Gameplay: ~1 request per minute (telemetry, leaderboards)
Asset Download: Hundreds of CDN requests (initial download only)
```

### Bandwidth:
```
API Requests: <10 KB per request (JSON)
API Responses: <50 KB per response (JSON)
Asset Downloads: 1.44 GB total (one-time download)
```

### Connection Pattern:
```
Type: Short-lived HTTP requests
Duration: <5 seconds per request
Keep-Alive: Disabled (new connection each time)
Concurrent: Max 4 concurrent connections
```

---

## 🎯 PORT SCANNING RR3 SERVERS (Historical)

### Known EA Server IPs:
```bash
# These were active before shutdown announcement
nslookup syn-dir.sn.eamobile.com
# Result: Various AWS/Akamai IPs

# Port scan would show:
Port 443: OPEN (HTTPS)
Port 80: CLOSED (HTTP disabled)
All other ports: CLOSED
```

### CDN Configuration:
```bash
nslookup firemonkeys.akamaized.net
# Result: Akamai edge servers (multiple IPs)

# Only port 443 open for asset delivery
```

---

## 💡 FOR YOUR DISCORD FRIEND

**Quick Answer:**
```
Q: What ports does RR3 use?

A: Just HTTPS on port 443. That's it.

No custom ports, no UDP, no websockets. 
Plain old HTTPS like any website.

Community server only needs:
- Port 443 open (HTTPS)
- Valid SSL certificate
- Standard web server (Nginx/Apache)
- Backend API (ASP.NET Core, Node, etc.)

Source code proof:
E:\rr3\decompiled\sources\com\ea\nimble\SynergyEnvironmentImpl.java
E:\rr3\decompiled\sources\com\ea\nimble\NetworkConnection.java

All URLs use https:// with no port specified = port 443 by default.
```

---

## 🔗 RELATED DOCUMENTATION

- **Endpoint Audit:** `E:\rr3\RR3CommunityServer\ENDPOINT_AUDIT.md`
- **APK Decompilation:** `E:\rr3\APK_DECOMPILATION_METHOD.md`
- **Server Implementation:** `E:\rr3\RR3CommunityServer\`

---

## ✅ VERIFICATION

### How to Verify:
```bash
# 1. Check HAR file (network capture)
# Location: G:\My Drive\pin-river.data.ea.com_2026_02_18_10_37_48.har
# Result: All requests use port 443

# 2. Check APK source code
# Files: NetworkConnection.java, SynergyEnvironmentImpl.java
# Result: No port configuration, uses URL defaults

# 3. Test with Wireshark/tcpdump
# Filter: tcp.port == 443
# Result: All RR3 traffic on port 443 only
```

---

## 📝 SUMMARY TABLE

| Aspect | Value |
|--------|-------|
| **Protocol** | HTTPS (HTTP over TLS/SSL) |
| **Port** | 443 (standard HTTPS) |
| **Connection Type** | HttpURLConnection (Java) |
| **Timeout** | 30 seconds (connect + read) |
| **SSL Verification** | Permissive (self-signed OK) |
| **Keep-Alive** | Disabled |
| **Max Concurrent** | 4 connections |
| **HTTP Version** | HTTP/1.1 |
| **Custom Ports?** | ❌ None |
| **UDP?** | ❌ No |
| **WebSocket?** | ❌ No |

---

**Bottom Line: RR3 is just a standard HTTPS client. Port 443 only.** 🌐✅
