Add support for initial d zero

titles/idz/userdb.py

@@ -0,0 +1,162 @@
+from twisted.internet.protocol import Factory, Protocol
+import logging, coloredlogs
+from Crypto.Cipher import AES
+import struct
+from typing import Dict, Optional, List, Type
+from twisted.web import server, resource
+from twisted.internet import reactor, endpoints
+from twisted.web.http import Request
+from routes import Mapper
+import random
+from os import walk
+import importlib
+
+from core.config import CoreConfig
+from .database import IDZData
+from .config import IDZConfig
+from .const import IDZConstants
+from .handlers import IDZHandlerBase
+
+HANDLER_MAP: List[Dict]
+
+class IDZKey:
+    def __init__(self, n, d, e, hashN: int) -> None:
+        self.N = n
+        self.d = d
+        self.e = e
+        self.hashN = hashN
+
+class IDZUserDBProtocol(Protocol):
+    def __init__(self, core_cfg: CoreConfig, game_cfg: IDZConfig, keys: List[IDZKey], handlers: List[Dict]) -> None:
+        self.logger = logging.getLogger('idz')
+        self.core_config = core_cfg
+        self.game_config = game_cfg
+        self.rsa_keys = keys
+        self.handlers = handlers
+        self.static_key = bytes.fromhex(self.game_config.server.aes_key)
+        self.version = None
+        self.version_internal = None
+        self.skip_next = False
+    
+    def append_padding(self, data: bytes):
+        """Appends 0s to the end of the data until it's at the correct size"""
+        length = struct.unpack_from("<H", data, 6)
+        padding_size = length[0] - len(data)
+        data += bytes(padding_size)
+        return data
+    
+    def connectionMade(self) -> None:
+        self.logger.debug(f"{self.transport.getPeer().host} Connected")
+        base = 0
+
+        for i in range(len(self.static_key) - 1):
+            shift = 8 * i
+            byte = self.static_key[i]
+
+            base |= byte << shift
+
+        rsa_key = random.choice(self.rsa_keys)
+        key_enc: int = pow(base, rsa_key.e, rsa_key.N)
+        result = key_enc.to_bytes(0x40, "little") + struct.pack("<I", 0x01020304) + rsa_key.hashN.to_bytes(4, "little")
+
+        self.logger.debug(f"Send handshake {result.hex()}")
+
+        self.transport.write(result)
+
+    def connectionLost(self, reason) -> None: 
+        self.logger.debug(
+            f"{self.transport.getPeer().host} Disconnected - {reason.value}"
+        )
+
+    def dataReceived(self, data: bytes) -> None:
+        self.logger.debug(f"Receive data {data.hex()}")
+        crypt = AES.new(self.static_key, AES.MODE_ECB)
+        data_dec = crypt.decrypt(data)
+        self.logger.debug(f"Decrypt data {data_dec.hex()}")
+
+        magic = struct.unpack_from("<I", data_dec, 0)[0]
+
+        if magic == 0xFE78571D:
+            # Ignore
+            self.logger.info(f"Userdb serverbox request {data_dec.hex()}")
+            self.skip_next = True
+
+            self.transport.write(b"\x00")
+            return
+
+        elif magic == 0x01020304:            
+            self.version = int(data_dec[16:19].decode())
+
+            if self.version == 110:
+                self.version_internal = IDZConstants.VER_IDZ_110
+            elif self.version == 130:
+                self.version_internal = IDZConstants.VER_IDZ_130
+            elif self.version == 210:
+                self.version_internal = IDZConstants.VER_IDZ_210
+            elif self.version == 230:
+                self.version_internal = IDZConstants.VER_IDZ_230
+            else:
+                self.logger.warn(f"Bad version v{self.version}")
+                self.version = None
+                self.version_internal = None
+            
+            self.logger.debug(f"Userdb v{self.version} handshake response from {self.transport.getPeer().host}")
+            return
+        
+        elif self.skip_next:
+            self.skip_next = False
+            self.transport.write(b"\x00")
+            return
+
+        elif self.version is None:
+            # We didn't get a handshake before, and this isn't one now, so we're up the creek
+            self.logger.info(f"Bad UserDB request from from {self.transport.getPeer().host}")
+            self.transport.write(b"\x00")
+            return
+
+        cmd = struct.unpack_from("<H", data_dec, 0)[0]
+        
+        handler_cls: Optional[Type[IDZHandlerBase]] = self.handlers[self.version_internal].get(cmd, None)
+        if handler_cls is None:
+            self.logger.warn(f"No handler for v{self.version} {hex(cmd)} cmd")
+            handler_cls = IDZHandlerBase
+        
+        handler = handler_cls(self.core_config, self.game_config, self.version_internal)        
+        self.logger.info(f"Userdb v{self.version} {handler.name} request from {self.transport.getPeer().host}")
+        response = handler.handle(data_dec)
+
+        self.logger.debug(f"Response: {response.hex()}")
+
+        crypt = AES.new(self.static_key, AES.MODE_ECB)
+        response_enc = crypt.encrypt(response)
+
+        self.transport.write(response_enc)
+
+
+class IDZUserDBFactory(Factory):
+    protocol = IDZUserDBProtocol
+
+    def __init__(self, cfg: CoreConfig, game_cfg: IDZConfig, keys: List[IDZKey], handlers: List[Dict]) -> None:
+        self.core_config = cfg
+        self.game_config = game_cfg
+        self.keys = keys
+        self.handlers = handlers
+
+    def buildProtocol(self, addr):
+        return IDZUserDBProtocol(self.core_config, self.game_config, self.keys, self.handlers)
+
+class IDZUserDBWeb(resource.Resource):
+    def __init__(self, core_cfg: CoreConfig, game_cfg: IDZConfig):
+        super().__init__()
+        self.isLeaf = True
+        self.core_config = core_cfg
+        self.game_config = game_cfg
+        self.logger = logging.getLogger('idz')
+    
+    def render_POST(self, request: Request) -> bytes:
+        self.logger.info(f"IDZUserDBWeb POST from {request.getClientAddress().host} to {request.uri} with data {request.content.getvalue()}")
+        return b""
+
+    def render_GET(self, request: Request) -> bytes:
+        self.logger.info(f"IDZUserDBWeb GET from {request.getClientAddress().host} to {request.uri}")
+        return b""