Merge pull request 'feature/SDHJ' (#215) from Keeboy/artemis:feature/SDHJ into develop

Reviewed-on: Hay1tsme/artemis#215

core/allnet.py

@@ -7,6 +7,7 @@ import logging
 import coloredlogs
 import urllib.parse
 import math
+import random
 from typing import Dict, List, Any, Optional, Union, Final
 from logging.handlers import TimedRotatingFileHandler
 from starlette.requests import Request
@@ -17,7 +18,10 @@ from datetime import datetime
 from enum import Enum
 from Crypto.PublicKey import RSA
 from Crypto.Hash import SHA
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad
 from Crypto.Signature import PKCS1_v1_5
+import os
 from os import path, environ, mkdir, access, W_OK
 
 from .config import CoreConfig
@@ -132,12 +136,29 @@ class AllnetServlet:
     async def handle_poweron(self, request: Request):
         request_ip = Utils.get_ip_addr(request)
         pragma_header = request.headers.get('Pragma', "")
+        useragent_header = request.headers.get('User-Agent', "")
         is_dfi = pragma_header == "DFI"
+        is_lite = useragent_header[5:] == "Windows/Lite"
+        lite_id = useragent_header[:4]
         data = await request.body()
 
+        if not self.config.allnet.allnet_lite_keys and is_lite:
+            self.logger.error("!!!LITE KEYS NOT SET!!!")
+            raise AllnetRequestException()
+        elif is_lite:
+            for gameids, key in self.config.allnet.allnet_lite_keys.items():
+                if gameids == lite_id:
+                    litekey = key
+
+        if is_lite and "litekey" not in locals():
+            self.logger.error("!!!UNIQUE LITE KEY NOT FOUND!!!")
+            raise AllnetRequestException()
+        
         try:
             if is_dfi:
                 req_urlencode = self.from_dfi(data)
+            elif is_lite:
+                req_urlencode = self.dec_lite(litekey, data[:16], data)
             else:
                 req_urlencode = data
 
@@ -145,9 +166,17 @@ class AllnetServlet:
             if req_dict is None:
                 raise AllnetRequestException()
 
+            if is_lite:
+                req = AllnetPowerOnRequestLite(req_dict[0])
+            else:
                 req = AllnetPowerOnRequest(req_dict[0])
             # Validate the request. Currently we only validate the fields we plan on using
 
+            if not req.game_id or not req.ver or not req.serial or not req.token and is_lite:
+                raise AllnetRequestException(
+                    f"Bad auth request params from {request_ip} - {vars(req)}"
+                )
+            elif not is_lite:
                 if not req.game_id or not req.ver or not req.serial or not req.ip or not req.firm_ver or not req.boot_ver:
                     raise AllnetRequestException( 
                         f"Bad auth request params from {request_ip} - {vars(req)}"
@@ -158,7 +187,9 @@ class AllnetServlet:
                 self.logger.error(e)
             return PlainTextResponse()
 
-        if req.format_ver == 3:
+        if is_lite:
+            resp = AllnetPowerOnResponseLite(req.token)
+        elif req.format_ver == 3:
             resp = AllnetPowerOnResponse3(req.token)
         elif req.format_ver == 2:
             resp = AllnetPowerOnResponse2()
@@ -175,11 +206,14 @@ class AllnetServlet:
             )
             self.logger.warning(msg)
 
+            if is_lite:
+                resp.result = ALLNET_STAT.bad_machine.value
+            else:
                 resp.stat = ALLNET_STAT.bad_machine.value
             resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
             return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
 
-        if machine is not None:
+        if machine is not None and not is_lite:
             arcade = await self.data.arcade.get_arcade(machine["arcade"])
             if self.config.server.check_arcade_ip:
                 if arcade["ip"] and arcade["ip"] is not None and arcade["ip"] != req.ip:
@@ -257,6 +291,9 @@ class AllnetServlet:
                 )
                 self.logger.warning(msg)
 
+                if is_lite:
+                    resp.result = ALLNET_STAT.bad_game.value
+                else:
                     resp.stat = ALLNET_STAT.bad_game.value
                 resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
                 return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
@@ -265,6 +302,10 @@ class AllnetServlet:
                 self.logger.info(
                     f"Allowed unknown game {req.game_id} v{req.ver} to authenticate from {request_ip} due to 'is_develop' being enabled. S/N: {req.serial}"
                 )
+                if is_lite:
+                    resp.uri1 = f"http://{self.config.server.hostname}:{self.config.server.port}/{req.game_id}/{req.ver.replace('.', '')}/"
+                    resp.uri2 = f"{self.config.server.hostname}:{self.config.server.port}"
+                else:
                     resp.uri = f"http://{self.config.server.hostname}:{self.config.server.port}/{req.game_id}/{req.ver.replace('.', '')}/"
                     resp.host = f"{self.config.server.hostname}:{self.config.server.port}"
                 
@@ -277,9 +318,15 @@ class AllnetServlet:
         
         int_ver = req.ver.replace(".", "")
         try:
+            if is_lite:
+                resp.uri1, resp.uri2 = TitleServlet.title_registry[req.game_id].get_allnet_info(req.game_id, int(int_ver), req.serial)
+            else:
                 resp.uri, resp.host = TitleServlet.title_registry[req.game_id].get_allnet_info(req.game_id, int(int_ver), req.serial)
         except Exception as e:
             self.logger.error(f"Error running get_allnet_info for {req.game_id} - {e}")
+            if is_lite:
+                resp.result = ALLNET_STAT.bad_game.value
+            else:
                 resp.stat = ALLNET_STAT.bad_game.value
             resp_dict = {k: v for k, v in vars(resp).items() if v is not None}
             return PlainTextResponse(urllib.parse.unquote(urllib.parse.urlencode(resp_dict)) + "\n")
@@ -308,18 +355,38 @@ class AllnetServlet:
                     "Pragma": "DFI",
                 },
             )
+        elif is_lite:
+            iv = bytes([random.randint(2, 255) for _ in range(16)])
+            return PlainTextResponse(content=self.enc_lite(litekey, iv, resp_str)) 
 
         return PlainTextResponse(resp_str)
 
     async def handle_dlorder(self, request: Request):
         request_ip = Utils.get_ip_addr(request)
         pragma_header = request.headers.get('Pragma', "")
+        useragent_header = request.headers.get('User-Agent', "")
         is_dfi = pragma_header == "DFI"
+        is_lite = useragent_header[5:] == "Windows/Lite"
+        lite_id = useragent_header[:4]
         data = await request.body()
         
+        if not self.config.allnet.allnet_lite_keys and is_lite:
+            self.logger.error("!!!LITE KEYS NOT SET!!!")
+            raise AllnetRequestException()
+        elif is_lite:
+            for gameids, key in self.config.allnet.allnet_lite_keys.items():
+                if gameids == lite_id:
+                    litekey = key
+
+        if is_lite and "litekey" not in locals():
+            self.logger.error("!!!UNIQUE LITE KEY NOT FOUND!!!")
+            raise AllnetRequestException()
+
         try:
             if is_dfi:
                 req_urlencode = self.from_dfi(data)
+            elif is_lite:
+                req_urlencode = self.dec_lite(litekey, data[:16], data)
             else:
                 req_urlencode = data.decode()
 
@@ -327,6 +394,9 @@ class AllnetServlet:
             if req_dict is None:
                 raise AllnetRequestException()
 
+            if is_lite:
+                req = AllnetDownloadOrderRequestLite(req_dict[0])
+            else:
                 req = AllnetDownloadOrderRequest(req_dict[0])
             # Validate the request. Currently we only validate the fields we plan on using
 
@@ -343,6 +413,10 @@ class AllnetServlet:
         self.logger.info(
             f"DownloadOrder from {request_ip} -> {req.game_id} v{req.ver} serial {req.serial}"
         )
+
+        if is_lite:
+            resp = AllnetDownloadOrderResponseLite()
+        else:
             resp = AllnetDownloadOrderResponse(serial=req.serial)
 
         if (
@@ -354,6 +428,9 @@ class AllnetServlet:
                 return PlainTextResponse(
                     self.to_dfi(resp) + b"\r\n", headers={ "Pragma": "DFI" }
                 )
+            elif is_lite:
+                iv = bytes([random.randint(2, 255) for _ in range(16)])
+                return PlainTextResponse(content=self.enc_lite(litekey, iv, resp)) 
             return PlainTextResponse(resp)
 
         else:
@@ -364,6 +441,9 @@ class AllnetServlet:
                     return PlainTextResponse(
                         self.to_dfi(resp) + b"\r\n", headers={ "Pragma": "DFI" }
                     )
+                elif is_lite:
+                    iv = bytes([random.randint(2, 255) for _ in range(16)])
+                    return PlainTextResponse(content=self.enc_lite(litekey, iv, resp)) 
                 return PlainTextResponse(resp)
 
             if path.exists(
@@ -393,6 +473,9 @@ class AllnetServlet:
                         "Pragma": "DFI",
                     },
                 )
+            elif is_lite:
+                iv = bytes([random.randint(2, 255) for _ in range(16)])
+                return PlainTextResponse(content=self.enc_lite(litekey, iv, res_str)) 
 
             return PlainTextResponse(res_str)
 
@@ -517,6 +600,17 @@ class AllnetServlet:
         zipped = zlib.compress(unzipped)
         return base64.b64encode(zipped)
 
+    def dec_lite(self, key, iv, data):
+        cipher = AES.new(bytes(key), AES.MODE_CBC, iv)
+        decrypted = cipher.decrypt(data)
+        return decrypted[16:].decode("utf-8")
+
+    def enc_lite(self, key, iv, data):
+        unencrypted = pad(bytes([0] * 16) + data.encode('utf-8'), 16)
+        cipher = AES.new(bytes(key), AES.MODE_CBC, iv)
+        encrypted = cipher.encrypt(unencrypted)
+        return encrypted
+
 class BillingServlet:
     def __init__(self, core_cfg: CoreConfig, cfg_folder: str) -> None:
         self.config = core_cfg
@@ -773,6 +867,15 @@ class AllnetPowerOnResponse:
         self.minute = datetime.now().minute
         self.second = datetime.now().second
 
+class AllnetPowerOnRequestLite:
+    def __init__(self, req: Dict) -> None:
+        if req is None:
+            raise AllnetRequestException("Request processing failed")
+        self.game_id: str = req.get("title_id", None)
+        self.ver: str = req.get("title_ver", None)
+        self.serial: str = req.get("client_id", None)
+        self.token: str = req.get("token", None)
+
 class AllnetPowerOnResponse3(AllnetPowerOnResponse):
     def __init__(self, token) -> None:
         super().__init__()
@@ -804,6 +907,30 @@ class AllnetPowerOnResponse2(AllnetPowerOnResponse):
         self.timezone = "+09:00"
         self.res_class = "PowerOnResponseV2"
 
+class AllnetPowerOnResponseLite:
+    def __init__(self, token) -> None:
+        # Custom Allnet Lite response
+        self.result = 1
+        self.place_id = "0123"
+        self.uri1 = ""
+        self.uri2 = ""
+        self.name = "ARTEMiS"
+        self.nickname = "ARTEMiS"
+        self.setting = "1"
+        self.region0 = "1"
+        self.region_name0 = "W"
+        self.region_name1 = ""
+        self.region_name2 = ""
+        self.region_name3 = ""
+        self.country = "CHN"
+        self.location_type = "1"
+        self.utc_time = datetime.now(tz=pytz.timezone("UTC")).strftime(
+            "%Y-%m-%dT%H:%M:%SZ"
+        )
+        self.client_timezone = "+0800"
+        self.res_ver = "3"
+        self.token = token
+
 class AllnetDownloadOrderRequest:
     def __init__(self, req: Dict) -> None:
         self.game_id = req.get("game_id", "")
@@ -811,12 +938,23 @@ class AllnetDownloadOrderRequest:
         self.serial = req.get("serial", "")
         self.encode = req.get("encode", "")
 
+class AllnetDownloadOrderRequestLite:
+    def __init__(self, req: Dict) -> None:
+        self.game_id = req.get("title_id", "")
+        self.ver = req.get("title_ver", "")
+        self.serial = req.get("client_id", "")
+
 class AllnetDownloadOrderResponse:
     def __init__(self, stat: int = 1, serial: str = "", uri: str = "null") -> None:
         self.stat = stat
         self.serial = serial
         self.uri = uri
 
+class AllnetDownloadOrderResponseLite:
+    def __init__(self, result: int = 1, uri: str = "null") -> None:
+        self.result = result
+        self.uri = uri
+
 class TraceDataType(Enum):
     CHARGE = 0
     EVENT = 1
@@ -1068,7 +1206,9 @@ app_billing = Starlette(
 allnet = AllnetServlet(cfg, cfg_dir)
 route_lst = [
     Route("/sys/servlet/PowerOn", allnet.handle_poweron, methods=["GET", "POST"]),
+    Route("/net/initialize", allnet.handle_poweron, methods=["GET", "POST"]),
     Route("/sys/servlet/DownloadOrder", allnet.handle_dlorder, methods=["GET", "POST"]),
+    Route("/net/delivery/instruction", allnet.handle_dlorder, methods=["GET", "POST"]),
     Route("/sys/servlet/LoaderStateRecorder", allnet.handle_loaderstaterecorder, methods=["GET", "POST"]),
     Route("/sys/servlet/Alive", allnet.handle_alive, methods=["GET", "POST"]),
     Route("/naomitest.html", allnet.handle_naomitest),

core/app.py

@@ -11,6 +11,7 @@ from typing import List
 
 from core import CoreConfig, TitleServlet, MuchaServlet
 from core.allnet import AllnetServlet, BillingServlet
+from core.chimedb import ChimeServlet
 from core.frontend import FrontendServlet
 
 async def dummy_rt(request: Request):
@@ -75,7 +76,9 @@ if not cfg.allnet.standalone:
     allnet = AllnetServlet(cfg, cfg_dir)
     route_lst += [
         Route("/sys/servlet/PowerOn", allnet.handle_poweron, methods=["GET", "POST"]),
+        Route("/net/initialize", allnet.handle_poweron, methods=["GET", "POST"]),
         Route("/sys/servlet/DownloadOrder", allnet.handle_dlorder, methods=["GET", "POST"]),
+        Route("/net/delivery/instruction", allnet.handle_dlorder, methods=["GET", "POST"]),
         Route("/sys/servlet/LoaderStateRecorder", allnet.handle_loaderstaterecorder, methods=["GET", "POST"]),
         Route("/sys/servlet/Alive", allnet.handle_alive, methods=["GET", "POST"]),
         Route("/naomitest.html", allnet.handle_naomitest),
@@ -87,6 +90,14 @@ if not cfg.allnet.standalone:
             Route("/dl/ini/{file:str}", allnet.handle_dlorder_ini),
         ]
 
+if cfg.chimedb.enable:
+    chimedb = ChimeServlet(cfg, cfg_dir)
+    route_lst += [
+        Route("/wc_aime/api/alive_check", chimedb.handle_qr_alive, methods=["POST"]),
+        Route("/qrcode/api/alive_check", chimedb.handle_qr_alive, methods=["POST"]),
+        Route("/wc_aime/api/get_data", chimedb.handle_qr_lookup, methods=["POST"])
+    ]
+
 for code, game in title.title_registry.items():
     route_lst += game.get_routes()
 

core/chimedb.py

@@ -0,0 +1,139 @@
+import hashlib
+import json
+import logging
+from enum import Enum
+from logging.handlers import TimedRotatingFileHandler
+
+import coloredlogs
+from starlette.responses import PlainTextResponse
+from starlette.requests import Request
+
+from core.config import CoreConfig
+from core.data import Data
+
+class ChimeDBStatus(Enum):
+    NONE = 0
+    READER_SETUP_FAIL = 1
+    READER_ACCESS_FAIL = 2
+    READER_INCOMPATIBLE = 3
+    DB_RESOLVE_FAIL = 4
+    DB_ACCESS_TIMEOUT = 5
+    DB_ACCESS_FAIL = 6
+    AIME_ID_INVALID = 7
+    NO_BOARD_INFO = 8
+    LOCK_BAN_SYSTEM_USER = 9
+    LOCK_BAN_SYSTEM = 10
+    LOCK_BAN_USER = 11
+    LOCK_BAN = 12
+    LOCK_SYSTEM_USER = 13
+    LOCK_SYSTEM = 14
+    LOCK_USER = 15
+
+class ChimeServlet:
+    def __init__(self, core_cfg: CoreConfig, cfg_folder: str) -> None:
+        self.config = core_cfg
+        self.config_folder = cfg_folder
+
+        self.data = Data(core_cfg)
+
+        self.logger = logging.getLogger("chimedb")
+        if not hasattr(self.logger, "initted"):
+            log_fmt_str = "[%(asctime)s] Chimedb | %(levelname)s | %(message)s"
+            log_fmt = logging.Formatter(log_fmt_str)
+
+            fileHandler = TimedRotatingFileHandler(
+                "{0}/{1}.log".format(self.config.server.log_dir, "chimedb"),
+                when="d",
+                backupCount=10,
+            )
+            fileHandler.setFormatter(log_fmt)
+
+            consoleHandler = logging.StreamHandler()
+            consoleHandler.setFormatter(log_fmt)
+
+            self.logger.addHandler(fileHandler)
+            self.logger.addHandler(consoleHandler)
+
+            self.logger.setLevel(self.config.aimedb.loglevel)
+            coloredlogs.install(
+                level=core_cfg.aimedb.loglevel, logger=self.logger, fmt=log_fmt_str
+            )
+            self.logger.initted = True
+
+        if not core_cfg.chimedb.key:
+            self.logger.error("!!!KEY NOT SET!!!")
+            exit(1)
+
+        self.logger.info("Serving")
+
+    async def handle_qr_alive(self, request: Request):
+        return PlainTextResponse("alive")
+
+    async def handle_qr_lookup(self, request: Request) -> bytes:
+        req = json.loads(await request.body())
+        access_code = req["qrCode"][-20:]
+        timestamp = req["timestamp"]
+
+        try:
+            userId = await self._lookup(access_code)
+            data = json.dumps({
+                "userID": userId,
+                "errorID": 0,
+                "timestamp": timestamp,
+                "key": self._hash_key(userId, timestamp)
+            })
+        except Exception as e:
+
+            self.logger.error(e.with_traceback(None))
+
+            data = json.dumps({
+                "userID": -1,
+                "errorID": ChimeDBStatus.DB_ACCESS_FAIL,
+                "timestamp": timestamp,
+                "key": self._hash_key(-1, timestamp)
+            })
+
+        return PlainTextResponse(data)
+
+    def _hash_key(self, chip_id, timestamp):
+        input_string = f"{chip_id}{timestamp}{self.config.chimedb.key}"
+        hash_object = hashlib.sha256(input_string.encode('utf-8'))
+        hex_dig = hash_object.hexdigest()
+
+        formatted_hex = format(int(hex_dig, 16), '064x').upper()
+
+        return formatted_hex
+
+    async def _lookup(self, access_code):
+        user_id = await self.data.card.get_user_id_from_card(access_code)
+
+        self.logger.info(f"access_code {access_code} -> user_id {user_id}")
+
+        if not user_id or user_id <= 0:
+            user_id = await self._register(access_code)
+
+        return user_id
+
+    async def _register(self, access_code):
+        user_id = -1
+
+        if self.config.server.allow_user_registration:
+            user_id = await self.data.user.create_user()
+
+            if user_id is None:
+                self.logger.error("Failed to register user!")
+                user_id = -1
+            else:
+                card_id = await self.data.card.create_card(user_id, access_code)
+
+                if card_id is None:
+                    self.logger.error("Failed to register card!")
+                    user_id = -1
+
+            self.logger.info(
+                f"Register access code {access_code} -> user_id {user_id}"
+            )
+        else:
+            self.logger.info(f"Registration blocked!: access code {access_code}")
+
+        return user_id

core/config.py

@@ -1,7 +1,7 @@
 import logging
 import os
 import ssl
-from typing import Any, Union
+from typing import Any, Union, Dict
 
 from typing_extensions import Optional
 
@@ -378,6 +378,11 @@ class AllnetConfig:
         return CoreConfig.get_config_field(
             self.__config, "core", "allnet", "save_billing", default=False
         )
+    @property
+    def allnet_lite_keys(self) -> Dict:
+        return CoreConfig.get_config_field(
+            self.__config, "core", "allnet", "allnet_lite_keys", default={}
+        )
 
 class BillingConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
@@ -469,6 +474,28 @@ class AimedbConfig:
             self.__config, "core", "aimedb", "id_lifetime_seconds", default=86400
         )
 
+class ChimedbConfig:
+    def __init__(self, parent_config: "CoreConfig") -> None:
+        self.__config = parent_config
+
+    @property
+    def enable(self) -> bool:
+        return CoreConfig.get_config_field(
+            self.__config, "core", "chimedb", "enable", default=True
+        )
+    @property
+    def loglevel(self) -> int:
+        return CoreConfig.str_to_loglevel(
+            CoreConfig.get_config_field(
+                self.__config, "core", "chimedb", "loglevel", default="info"
+            )
+        )
+    @property
+    def key(self) -> str:
+        return CoreConfig.get_config_field(
+            self.__config, "core", "chimedb", "key", default=""
+        )
+
 class MuchaConfig:
     def __init__(self, parent_config: "CoreConfig") -> None:
         self.__config = parent_config
@@ -490,6 +517,7 @@ class CoreConfig(dict):
         self.allnet = AllnetConfig(self)
         self.billing = BillingConfig(self)
         self.aimedb = AimedbConfig(self)
+        self.chimedb = ChimedbConfig(self)
         self.mucha = MuchaConfig(self)
 
     @classmethod

docs/config.md

@@ -41,6 +41,13 @@
 - `loglevel`: Logging level for the allnet server. Default `info`
 - `allow_online_updates`: Allow allnet to distribute online updates via DownloadOrders. This system is currently non-functional, so leave it disabled. Default `False`
 - `update_cfg_folder`: Folder where delivery INI files will be checked for. Ignored if `allow_online_updates` is `False`. Default `""`
+- `allnet_lite_keys:` Allnet Lite (Chinese Allnet) PowerOn/DownloadOrder unique keys. Default ` `
+```yaml
+  allnet_lite_keys: 
+    "SDJJ": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
+    "SDHJ": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
+    "SDGB": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
+```
 ## Billing
 - `standalone`: Whether the billing server should launch it's own servlet on it's own port, or be part of the main servlet on the default port. Setting this to `True` requires that you have `ssl_key` and `ssl_cert` set. Default `False`
 - `loglevel`: Logging level for the billing server. Default `info`
@@ -56,3 +63,8 @@
 - `key`: Key to encrypt/decrypt aimedb requests and responses. MUST be set or the server will not start. If set incorrectly, your server will not properly handle aimedb requests. Default `""`
 - `id_secret`: Base64-encoded JWT secret for Sega Auth IDs. Leaving this blank disables this feature. Default `""`
 - `id_lifetime_seconds`: Number of secons a JWT generated should be valid for. Default `86400` (1 day)
+## Chimedb
+- `enable`: Whether or not chimedb should run. Default `False`
+- `loglevel`: Logging level for the chimedb server. Default `info`
+- `key`: Key to hash chimedb requests and responses. MUST be set or the server will not start. If set incorrectly, your server will not properly handle chimedb requests. Default `""`
+

docs/game_specific_info.md

@@ -108,6 +108,7 @@ crypto:
   keys:
     13: ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000"]
     "13_int": ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000", 42]
+	"13_chn": ["0000000000000000000000000000000000000000000000000000000000000000", "00000000000000000000000000000000", "0000000000000000", 8]
 ```
 
 ### Database upgrade

example_config/core.yaml

@@ -46,6 +46,7 @@ allnet:
   allow_online_updates: False
   update_cfg_folder: ""
   save_billing: True
+  allnet_lite_key: []
 
 billing:
   standalone: True
@@ -64,5 +65,10 @@ aimedb:
   id_secret: ""
   id_lifetime_seconds: 86400
 
+chimedb:
+  enable: False
+  loglevel: "info"
+  key: ""
+
 mucha:
   loglevel: "info"

readme.md

@@ -8,6 +8,11 @@ Games listed below have been tested and confirmed working. Only game versions ol
     + 1.30
     + 1.35
 
++ CHUNITHM CHINA
+    + NEW
+    + 2024 (NEW)
+    + 2024 (LUMINOUS)
+
 + CHUNITHM INTL
     + SUPERSTAR
     + SUPERSTAR PLUS
@@ -15,6 +20,8 @@ Games listed below have been tested and confirmed working. Only game versions ol
     + NEW PLUS
     + SUN
     + SUN PLUS
+    + LUMINOUS
+    + LUMINOUS PLUS
 
 + CHUNITHM JP
     + AIR
@@ -43,7 +50,29 @@ Games listed below have been tested and confirmed working. Only game versions ol
 + Initial D THE ARCADE
     + Season 2
 
++ maimai DX CHINA
+    + DX (Muji)
+    + 2021 (Muji)
+    + 2022 (Muji)
+    + 2023 (FESTiVAL)
+    + 2024 (BUDDiES)
+
++ maimai DX INTL
+    + DX
+    + DX Plus
+    + Splash
+    + Splash Plus
+    + UNiVERSE
+    + UNiVERSE PLUS
+    + FESTiVAL
+    + FESTiVAL PLUS
+    + BUDDiES
+    + BUDDiES PLUS
+    + PRiSM
+    
 + maimai DX
+    + DX
+    + DX Plus
     + Splash
     + Splash Plus
     + UNiVERSE

titles/chuni/__init__.py

@@ -8,4 +8,4 @@ index = ChuniServlet
 database = ChuniData
 reader = ChuniReader
 frontend = ChuniFrontend
-game_codes = [ChuniConstants.GAME_CODE, ChuniConstants.GAME_CODE_NEW, ChuniConstants.GAME_CODE_INT]
+game_codes = [ChuniConstants.GAME_CODE, ChuniConstants.GAME_CODE_NEW, ChuniConstants.GAME_CODE_INT, ChuniConstants.GAME_CODE_CHN]

titles/chuni/const.py

@@ -6,6 +6,7 @@ class ChuniConstants:
     GAME_CODE = "SDBT"
     GAME_CODE_NEW = "SDHD"
     GAME_CODE_INT = "SDGS"
+    GAME_CODE_CHN = "SDHJ"
 
     CONFIG_NAME = "chuni.yaml"
 

titles/chuni/index.py

@@ -101,14 +101,17 @@ class ChuniServlet(BaseServlet):
             f"{ChuniConstants.VER_CHUNITHM_PARADISE}_int": 51, # SUPERSTAR PLUS
             ChuniConstants.VER_CHUNITHM_NEW: 54,
             f"{ChuniConstants.VER_CHUNITHM_NEW}_int": 49,
+            f"{ChuniConstants.VER_CHUNITHM_NEW}_chn": 37,
             ChuniConstants.VER_CHUNITHM_NEW_PLUS: 25,
             f"{ChuniConstants.VER_CHUNITHM_NEW_PLUS}_int": 31,
+            f"{ChuniConstants.VER_CHUNITHM_NEW_PLUS}_chn": 35, # NEW
             ChuniConstants.VER_CHUNITHM_SUN: 70,
             f"{ChuniConstants.VER_CHUNITHM_SUN}_int": 35,
             ChuniConstants.VER_CHUNITHM_SUN_PLUS: 36,
             f"{ChuniConstants.VER_CHUNITHM_SUN_PLUS}_int": 36,
             ChuniConstants.VER_CHUNITHM_LUMINOUS: 8,
             f"{ChuniConstants.VER_CHUNITHM_LUMINOUS}_int": 8,
+            f"{ChuniConstants.VER_CHUNITHM_LUMINOUS}_chn": 8,
             ChuniConstants.VER_CHUNITHM_LUMINOUS_PLUS: 56,
         }
 
@@ -150,6 +153,11 @@ class ChuniServlet(BaseServlet):
                     and version_idx >= ChuniConstants.VER_CHUNITHM_NEW
                 ):
                     method_fixed += "C3Exp"
+                elif (
+                    isinstance(version, str)
+                    and version.endswith("_chn")
+                ):
+                    method_fixed += "Chn"
                     
                 hash = PBKDF2(
                     method_fixed,
@@ -259,6 +267,13 @@ class ChuniServlet(BaseServlet):
               internal_ver = ChuniConstants.VER_CHUNITHM_LUMINOUS
           elif version >= 135: # LUMINOUS PLUS
               internal_ver = ChuniConstants.VER_CHUNITHM_LUMINOUS_PLUS
+        elif game_code == "SDHJ": # Chn
+          if version < 110: # NEW
+              internal_ver = ChuniConstants.VER_CHUNITHM_NEW
+          elif version >= 110 and version < 120: # NEW *Cursed but needed due to different encryption key
+              internal_ver = ChuniConstants.VER_CHUNITHM_NEW_PLUS
+          elif version >= 120: # LUMINOUS
+              internal_ver = ChuniConstants.VER_CHUNITHM_LUMINOUS
 
         if all(c in string.hexdigits for c in endpoint) and len(endpoint) == 32:
             # If we get a 32 character long hex string, it's a hash and we're
@@ -268,6 +283,9 @@ class ChuniServlet(BaseServlet):
             if game_code == "SDGS":
                 crypto_cfg_key = f"{internal_ver}_int"
                 hash_table_key = f"{internal_ver}_int"
+            elif game_code == "SDHJ":
+                crypto_cfg_key = f"{internal_ver}_chn"
+                hash_table_key = f"{internal_ver}_chn"
             else:
                 crypto_cfg_key = internal_ver
                 hash_table_key = internal_ver
@@ -337,6 +355,8 @@ class ChuniServlet(BaseServlet):
             endpoint = endpoint.replace("C3Exp", "")
         elif game_code == "SDGS" and version < 110:
             endpoint = endpoint.replace("Exp", "")
+        elif game_code == "SDHJ":
+            endpoint = endpoint.replace("Chn", "")
         else:
             endpoint = endpoint
 

titles/mai2/__init__.py

@@ -18,4 +18,5 @@ game_codes = [
     Mai2Constants.GAME_CODE_GREEN,
     Mai2Constants.GAME_CODE,
     Mai2Constants.GAME_CODE_DX_INT,
+    Mai2Constants.GAME_CODE_DX_CHN,
 ]

titles/mai2/base.py

@@ -139,6 +139,9 @@ class Mai2Base:
     async def handle_get_game_ng_music_id_api_request(self, data: Dict) -> Dict:
         return {"length": 0, "musicIdList": []}
 
+    async def handle_get_game_ng_word_list_api_request(self, data: Dict) -> Dict:
+        return {"ngWordExactMatchLength": 0, "ngWordExactMatchList": [], "ngWordPartialMatchLength": 0, "ngWordPartialMatchList": []}
+
     async def handle_get_game_charge_api_request(self, data: Dict) -> Dict:
         game_charge_list = await self.data.static.get_enabled_tickets(self.version, 1)
         if game_charge_list is None:

titles/mai2/const.py

@@ -32,6 +32,7 @@ class Mai2Constants:
     GAME_CODE_FINALE = "SDEY"
     GAME_CODE_DX = "SDEZ"
     GAME_CODE_DX_INT = "SDGA"
+    GAME_CODE_DX_CHN = "SDGB"
 
     CONFIG_NAME = "mai2.yaml"
 

titles/mai2/index.py

@@ -337,6 +337,20 @@ class Mai2Servlet(BaseServlet):
           elif version >=150:
               internal_ver = Mai2Constants.VER_MAIMAI_DX_PRISM
 
+        elif game_code == "SDGB": # Chn
+          if version < 110:  # Muji
+              internal_ver = Mai2Constants.VER_MAIMAI_DX
+          elif version >= 110 and version < 120:  # Muji
+              internal_ver = Mai2Constants.VER_MAIMAI_DX
+          elif version >= 120 and version < 130:  # Muji (LMAO)
+              internal_ver = Mai2Constants.VER_MAIMAI_DX
+          elif version >= 130 and version < 140:  # FESTiVAL
+              internal_ver = Mai2Constants.VER_MAIMAI_DX_FESTIVAL
+          elif version >= 140 and version < 150:  # BUDDiES
+              internal_ver = Mai2Constants.VER_MAIMAI_DX_BUDDIES
+          elif version >=150:
+              internal_ver = Mai2Constants.VER_MAIMAI_DX_PRISM
+
         if all(c in string.hexdigits for c in endpoint) and len(endpoint) == 32:
             # If we get a 32 character long hex string, it's a hash and we're
             # dealing with an encrypted request. False positives shouldn't happen
@@ -403,6 +417,8 @@ class Mai2Servlet(BaseServlet):
         endpoint = (
             endpoint.replace("MaimaiExp", "")
             if game_code == Mai2Constants.GAME_CODE_DX_INT
+            else endpoint.replace("MaimaiChn", "")
+            if game_code == Mai2Constants.GAME_CODE_DX_CHN
             else endpoint
         )
         func_to_find = "handle_" + inflection.underscore(endpoint) + "_request"