sssekai 0.0.3__py3-none-any.whl

sssekai/__init__.py

@@ -0,0 +1,6 @@
+__VERSION_MAJOR__ = 0
+__VERSION_MINOR__ = 0
+__VERSION_PATCH__ = 3
+
+__version__ = '%s.%s.%s' % (__VERSION_MAJOR__,__VERSION_MINOR__,__VERSION_PATCH__)
+    

sssekai/__main__.py

@@ -0,0 +1,77 @@
+import codecs
+import sys, os
+import argparse
+from sssekai.entrypoint.apidecrypt import main_apidecrypt
+from sssekai.entrypoint.abdecrypt import main_abdecrypt
+from sssekai.entrypoint.mitm import main_mitm
+from sssekai.entrypoint.usmdemux import main_usmdemux
+from sssekai.entrypoint.abcache import main_abcache, DEFAULT_CACHE_DIR
+from sssekai.entrypoint.live2dextract import main_live2dextract
+from sssekai.unity import SEKAI_UNITY_VERSION
+def __main__():
+    import coloredlogs
+    from logging import basicConfig
+    coloredlogs.install(
+            level='INFO',
+            fmt="%(asctime)s %(name)s [%(levelname).4s] %(message)s",
+            isatty=True,
+        )
+    basicConfig(
+        level='INFO', format="[%(levelname).4s] %(name)s %(message)s"
+    )
+    
+    parser = argparse.ArgumentParser(description='''SSSekai Proejct SEKAI feat. Hatsune Miku (Android) Modding Tools
+Installation:
+    pip install git+https://github.com/mos9527/sssekai                                    
+''', formatter_class=argparse.RawTextHelpFormatter)
+    subparsers = parser.add_subparsers(title='subcommands', description='valid subcommands', help='additional help')
+    # apidecrypt
+    apidecrypt_parser = subparsers.add_parser('apidecrypt', help='''API crypto dumper
+This crypto applies to:
+    - API request/response body dumped by packet sniffer (mitmproxy, wireshark, etc.)
+    - AssetBundleInfo (can be found at /sdcard/Android/data/com.hermes.mk.asia/files/data/AssetBundleInfo,or see sssekai.abcache)''')
+    apidecrypt_parser.add_argument('infile', type=str, help='input dump file')
+    apidecrypt_parser.add_argument('outfile', type=str, help='output json file')
+    apidecrypt_parser.set_defaults(func=main_apidecrypt)
+    # abdecrypt
+    abdecrypt_parser = subparsers.add_parser('abdecrypt', help='''Decrypt Sekai AssetBundle
+These can be found at /sdcard/Android/data/com.hermes.mk.asia/files/data/                                             
+''')
+    abdecrypt_parser.add_argument('indir', type=str, help='input directory')
+    abdecrypt_parser.add_argument('outdir', type=str, help='output directory')
+    abdecrypt_parser.set_defaults(func=main_abdecrypt)
+    # usmdemux
+    usmdemux_parser = subparsers.add_parser('usmdemux', help='''Demux Sekai USM Video in a AssetBundle''')
+    usmdemux_parser.add_argument('infile', type=str, help='input file')
+    usmdemux_parser.add_argument('outdir', type=str, help='output directory')
+    usmdemux_parser.set_defaults(func=main_usmdemux)
+    # abcache
+    abcache_parser = subparsers.add_parser('abcache', help='''Sekai AssetBundle local cache
+Downloads/Updates *ALL* PJSK JP assets to local devices.
+NOTE: The assets can take quite a lot of space (est. 42.5GB) so be prepared
+NOTE: The AssetBundles *cached* are NOT OBFUSCATED. They can be used as is by various Unity ripping tools (and sssekai by extension)
+      that supports stripped Unity version (should be %s. the version is ripped).''' % SEKAI_UNITY_VERSION)
+    abcache_parser.add_argument('--cache-dir', type=str, help='cache directory',default=DEFAULT_CACHE_DIR)
+    abcache_parser.add_argument('--skip-update',action='store_true',help='skip all updates and use cached assets as is.')
+    abcache_parser.add_argument('--open', action='store_true',help='open cache directory. this will skip all updates.')
+    abcache_parser.set_defaults(func=main_abcache)
+    # live2dextract
+    live2dextract_parser = subparsers.add_parser('live2dextract', help='''Extract Sekai Live2D Models in a AssetBundle''')
+    live2dextract_parser.add_argument('infile', type=str, help='input file')
+    live2dextract_parser.add_argument('outdir', type=str, help='output directory')
+    live2dextract_parser.add_argument('--no-anim',action='store_true',help='don\'t extract animation clips')
+    live2dextract_parser.set_defaults(func=main_live2dextract)
+    # mitm
+    mitm_parser = subparsers.add_parser('mitm', help='Run Sekai API MITM proxy (WIP)')
+    mitm_parser.set_defaults(func=main_mitm)
+    # parse args
+    args = parser.parse_args()
+    if 'func' in args:
+        args.func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    __main__()
+    sys.exit(0)

sssekai/abcache/__init__.py

@@ -0,0 +1,190 @@
+from os import path, remove, makedirs, stat
+from typing import List, Mapping
+from dataclasses import dataclass, asdict
+from requests import Session
+from logging import getLogger
+from json import dump, load
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor
+logger = getLogger('sssekai.abcache')
+
+from sssekai.crypto.APIManager import decrypt
+from sssekai.crypto.AssetBundle import decrypt_headaer_inplace, SEKAI_AB_MAGIC
+from msgpack import unpackb
+from tqdm import tqdm
+DEFAULT_CACHE_DIR = '~/.sssekai/abcache'
+# 2.6.1
+SEKAI_CDN = 'https://production-cf2d2388-assetbundle-info.sekai.colorfulpalette.org/'
+SEKAI_AB_CDN = 'https://production-cf2d2388-assetbundle.sekai.colorfulpalette.org/'
+SEKAI_AB_BASE_PATH = '3.3.0.20/8fd5e993-0146-c881-8902-4ed113efcdbf/android/'
+SEKAI_AB_INDEX_PATH = 'api/version/3.3.0.20/os/android'
+# HACK: Bypasses the check for now. Would this expire though?
+SEKAI_API_COOKIES = 'CloudFront-Policy=eyJTdGF0ZW1lbnQiOlt7IlJlc291cmNlIjoiKiIsIkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTcwNzcwNDc1Nn0sIklwQWRkcmVzcyI6eyJBV1M6U291cmNlSXAiOiIwLjAuMC4wLzAifX19XX0_; CloudFront-Signature=KKEPARo-8R5aSq~AsEyXL~Bl7OaZ5P7U7KhxcQCjCtgVeCTdLxehu3fUt22cS-UOg25ZhzLLc4vEsFFTAz4LPq~I7lOZcGNj5Jan5-fQg52iRHVnZw~otkRrrsyZh6aDnKMxeNmqSOBtvf4Nw0tqe6vRPo398l6IqBeHZ-5owKQxG0SreAmq1wm8VSnMTow2l5Atxw~reEqQ9TFsktMsebL1eqExROXF4e~135zrcFuN9C~vPOs4m9CogLaYKPXcCau-l1D~Qs7PXXL3ZSY6r40kwdICfd50MiVM14Ip~926Xh6MO3BfEGR20WFqCA-VPGfa3ANUHR9Rj-Gzddxlrw__; CloudFront-Key-Pair-Id=KV6QGCE0D633X;'
+class ThreadpoolDownloader(ThreadPoolExecutor):
+    session : Session
+    progress : tqdm
+
+    def download(self, url, fname, length):
+        RETRIES = 1
+        for _ in range(0,RETRIES):
+            try:
+                resp = self.session.get(url,stream=True)
+                resp.raise_for_status()
+                makedirs(path.dirname(fname),exist_ok=True)
+                with open(fname, 'wb') as f:
+                    magic = next(resp.iter_content(4))
+                    if magic == SEKAI_AB_MAGIC:
+                        header = next(resp.iter_content(128))            
+                        self.progress.update(128)
+                        f.write(decrypt_headaer_inplace(bytearray(header)))
+                    else:
+                        f.write(magic)                
+                    for chunk in resp.iter_content(65536):
+                        self.progress.update(len(chunk))
+                        f.write(chunk)
+                    return
+            except Exception as e:
+                logger.error('While downloading %s : %s. Retrying' % (url,e))
+        if _ == RETRIES - 1:
+            logger.critical('Did not download %s' % url)
+    def add_link(self, url, fname, length):
+        self.progress.total += length
+        return self.submit(self.download, url, fname, length)
+    def __init__(self, session = None) -> None:
+        self.session = session or Session()
+        self.progress = tqdm(bar_format="{desc}: {percentage:.1f}%|{bar}| {n_fmt}/{total_fmt} {rate_fmt} {elapsed}<{remaining}", total=0,unit='B', unit_scale=True, unit_divisor=1024,desc="Downloading")
+        super().__init__() # workers = processor count * 5
+
+class AbCacheConfig:
+    cache_dir : str # absolute path to cache directory
+    downloader : ThreadpoolDownloader
+    def __init__(self, downloader : ThreadpoolDownloader, cache_dir: str = DEFAULT_CACHE_DIR) -> None:
+        self.cache_dir = path.expanduser(cache_dir)
+        self.cache_dir = path.abspath(self.cache_dir)
+        self.downloader = downloader
+
+@dataclass
+class AbCacheEntry(dict):
+    bundleName: str
+    cacheFileName: str
+    cacheDirectoryName: str
+    hash: str
+    category: str
+    crc: int
+    fileSize:int
+    dependencies : List[str]
+    paths : List[str]
+    isBuiltin : bool
+
+    def up_to_date(self, config: AbCacheConfig, other) -> bool:
+        fsize = self.get_file_size(config)     
+        return self.hash == other.hash and self.fileSize <= fsize # fsize may be fileSize + 4
+    
+    def get_file_size(self, config: AbCacheConfig):
+        if self.get_file_exists(config):
+            return stat(self.get_file_path(config)).st_size
+        else:
+            return 0
+
+    def get_file_exists(self, config: AbCacheConfig) -> bool:
+        return path.exists(self.get_file_path(config))
+    
+    def get_file_path(self, config: AbCacheConfig) -> str:
+        return path.join(config.cache_dir, self.bundleName)
+@dataclass
+class AbCacheIndex(dict):
+    version : str = 'unknown'
+    os : str = 'android'
+    bundles : Mapping[str, AbCacheEntry] = None
+    def get_bundle_by_abcache_path(self, config: AbCacheConfig, fpath) -> AbCacheEntry | None:
+        # "C:\Users\mos9527\.sssekai\abcache\title_screen\anniversary_2nd_bg"
+        fpath = Path(fpath)
+        cpath = Path(config.cache_dir)
+        assert fpath.is_relative_to(cpath), "File provided is not inside the cache"
+        relpath = fpath.relative_to(cpath).as_posix()
+        return self.bundles.get(relpath,None)
+    
+class AbCache(Session):
+    config : AbCacheConfig
+    index : AbCacheIndex
+    
+    def download_cache_index(self) -> AbCacheIndex:
+        resp = self.get(
+            url=SEKAI_CDN + SEKAI_AB_INDEX_PATH,
+            headers={
+                'Accept-Encoding': 'deflate, gzip'
+            }
+        )
+        resp.raise_for_status()
+        data = decrypt(resp.content)
+        data = unpackb(data)
+        cache = AbCacheIndex(**data)
+        for k,v in cache.bundles.items():
+            cache.bundles[k] = AbCacheEntry(**v)
+        return cache
+
+    def update_cahce_entry(self, entry : AbCacheEntry, new_entry : AbCacheEntry = None):
+        if new_entry:
+            entry = new_entry
+        return self.config.downloader.add_link(
+            SEKAI_AB_CDN + SEKAI_AB_BASE_PATH + entry.bundleName,
+            entry.get_file_path(self.config),
+            entry.fileSize
+        )
+                
+    def update_cahce_index(self):
+        logger.info('Downloading Asset Bundle Index')
+        dl = self.download_cache_index()
+        all_keys = sorted(list({k for k in dl.bundles.keys()}.union({k for k in self.index.bundles.keys()})))
+        update_count = 0
+        for k in all_keys:
+            if k in dl.bundles and k in self.index.bundles:
+                # update
+                if not dl.bundles[k].up_to_date(self.config, self.index.bundles[k]):
+                    logger.info('Updating bundle %s', k)
+                    self.update_cahce_entry(self.index.bundles[k], dl.bundles[k])
+                    update_count+=1
+                else:
+                    logger.debug('Bundle %s is up to date' % k)
+                    pass
+            elif k in dl.bundles: 
+                # append
+                logger.debug('Adding bundle %s', k)
+                self.index.bundles[k] = dl.bundles[k]
+                self.update_cahce_entry(self.index.bundles[k])
+                update_count+=1
+            else: 
+                # removal
+                logger.info('Removing bundle %s', k)
+                if path.exists(self.index.bundles[k].get_file_path(self.config)):
+                    remove(self.index.bundles[k].get_file_path(self.config))
+                del self.index.bundles[k]
+        logger.info('Saving AssetBundle index')
+        self.save()
+        logger.info('...Saved. Need %d updates' % update_count)
+        self.config.downloader.shutdown(wait=True)
+        logger.info('AssetBundles are now up-to-date')
+    
+    def __init__(self, config : AbCacheConfig) -> None:
+        super().__init__()        
+        self.headers['Cookie'] = SEKAI_API_COOKIES
+        self.config = config
+        makedirs(self.config.cache_dir,exist_ok=True)
+        try:
+            self.load()
+        except Exception as e:
+            logger.warning('Failed to load cache index. Creating new one. (%s)' % e)
+            self.index = AbCacheIndex(bundles=dict())
+            self.save()
+    
+    def save(self):
+        with open(path.join(self.config.cache_dir, 'abindex.json'),'w',encoding='utf-8') as f:
+            dump(asdict(self.index), f, indent=4, ensure_ascii=False)
+            logger.info("Saved %d entries to cache index" % len(self.index.bundles))
+
+    def load(self):
+        with open(path.join(self.config.cache_dir, 'abindex.json'),'r',encoding='utf-8') as f:
+            self.index = AbCacheIndex(**load(f))
+            for k,v in self.index.bundles.items():
+                self.index.bundles[k] = AbCacheEntry(**v)
+            logger.info("Loaded %d entries from cache index" % len(self.index.bundles))

sssekai/crypto/APIManager.py

@@ -0,0 +1,24 @@
+from Crypto.Cipher import AES
+def PKCS7_pad(data : bytes,bs) -> bytes:
+    size = (bs - len(data) % bs)
+    return data + bytes([size] * size)
+
+def PKCS7_unpad(data : bytes,bs) -> bytes:
+    pad = data[-1]
+    return data[:-pad]
+
+def decrypt_aes_cbc(data : bytes, key, iv, unpad=PKCS7_unpad) -> bytes:
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    return unpad(cipher.decrypt(data), cipher.block_size)
+
+def encrypt_aes_cbc(data : bytes, key, iv, pad=PKCS7_pad) -> bytes:
+    cipher = AES.new(key, AES.MODE_CBC, iv)
+    return cipher.encrypt(pad(data, cipher.block_size))
+
+SEKAI_APIMANAGER_KEY = b"g2fcC0ZczN9MTJ61"
+SEKAI_APIMANAGER_IV = b"msx3IV0i9XE5uYZ1"
+def encrypt(data : bytes) -> bytes:
+    return encrypt_aes_cbc(data,SEKAI_APIMANAGER_KEY,SEKAI_APIMANAGER_IV, PKCS7_pad)
+
+def decrypt(data : bytes) -> bytes:
+    return decrypt_aes_cbc(data,SEKAI_APIMANAGER_KEY,SEKAI_APIMANAGER_IV, PKCS7_unpad)

sssekai/crypto/AssetBundle.py

@@ -0,0 +1,32 @@
+from io import BytesIO
+from typing import BinaryIO
+
+SEKAI_AB_MAGIC = b'\x10\x00\x00\x00'
+def decrypt_headaer_inplace(header : bytearray):
+    assert len(header) == 128
+    for i in range(0,128,8):       
+        for j in range(5):
+            header[i + j] = ~header[i + j] & 0xff
+    return header
+
+def decrypt(fin : BinaryIO, fout : BinaryIO = None) -> None:      
+    if not fout:
+        fout = BytesIO()
+    magic = fin.read(4)    
+    if magic == SEKAI_AB_MAGIC:
+        fout.write(decrypt_headaer_inplace(bytearray(fin.read(128))))
+        while (block := fin.read(65536)):
+            fout.write(block)    
+    else:
+        fin.seek(0)
+        while (block := fin.read(65536)):
+            fout.write(block)
+    return fout
+
+def encrypt(fin, fout):
+    raise NotImplementedError
+
+def has_magic(fin : BinaryIO) -> bool:
+    magic = fin.read(4)
+    fin.seek(0)
+    return magic == SEKAI_AB_MAGIC

sssekai/entrypoint/abcache.py

@@ -0,0 +1,16 @@
+from sssekai.abcache import AbCache, AbCacheConfig,ThreadpoolDownloader, logger, DEFAULT_CACHE_DIR
+def main_abcache(args):
+    downloader = ThreadpoolDownloader()
+    cache_dir = args.cache_dir or DEFAULT_CACHE_DIR
+    config = AbCacheConfig(downloader, cache_dir)
+    if args.open:
+        from os import startfile
+        startfile(config.cache_dir)
+        return
+    cache = AbCache(config)
+    downloader.session = cache
+    if not args.skip_update:
+        cache.update_cahce_index()
+    downloader.shutdown()
+    cache.save()
+    logger.info('AssetBundle cache is now ready. Visit: %s' % cache_dir)

sssekai/entrypoint/abdecrypt.py

@@ -0,0 +1,9 @@
+import os
+def main_abdecrypt(args):
+    from sssekai.crypto.AssetBundle import decrypt
+    tree = os.walk(args.indir)
+    for root, dirs, files in tree:
+        for fname in files:
+            file = os.path.join(root,fname)
+            if (os.path.isfile(file)):
+                decrypt(open(file,'rb'), open(os.path.join(args.outdir, fname),'wb'))

sssekai/entrypoint/apidecrypt.py

@@ -0,0 +1,9 @@
+import os
+def main_apidecrypt(args):
+    from sssekai.crypto.APIManager import decrypt
+    import json, msgpack
+    data = open(args.infile,'rb').read()
+    with open(args.outfile,'w',encoding='utf-8') as fout:
+        plain = decrypt(data)
+        msg = msgpack.unpackb(plain)
+        json.dump(msg, fout, indent=4, ensure_ascii=False)

sssekai/entrypoint/live2dextract.py

@@ -0,0 +1,165 @@
+from sssekai.unity.AssetBundle import load_assetbundle
+from sssekai.unity.AnimationClip import read_animation
+from UnityPy.classes import AnimationClip
+from os import path,remove,makedirs
+from logging import getLogger
+import json
+logger = getLogger(__name__)
+
+# Thanks! https://github.com/Perfare/UnityLive2DExtractor/blob/master/UnityLive2DExtractor/CubismMotion3Converter.cs
+def animation_clip_to_live2d_motion3(animationClip: AnimationClip, pathTable : dict) -> dict:
+    '''Convert Unity AnimationClip to Live2D Motion3 format
+
+    Args:
+        animationClip (AnimationClip): animationClip
+        pathTable (dict): CRC32 to Live2D path table
+
+    Returns:
+        dict: Live2D Motion3 data
+    '''
+    motion = {
+            'Version': 3,
+            'Meta': {
+                "Name":animationClip.m_Name,
+                "Duration":animationClip.m_MuscleClip.m_StopTime,
+                "Fps":animationClip.m_SampleRate,
+                "Loop":True,
+                "AreBeziersRestricted":True,
+                "CurveCount":0,
+                "UserDataCount":0,
+                "TotalPointCount":0,
+                "TotalSegmentCount":0,
+                "TotalUserDataSize":0
+            },
+            'Curves': [],
+            'UserData': []
+        }
+    animation = read_animation(animationClip)
+    floatCurves = animation.FloatTracks
+    motion['Meta']['CurveCount'] = len(floatCurves)
+    for track in [track for path in floatCurves.values() for track in path.values()]:
+        segments = list()
+        segments.append(0)
+        segments.append(track.Curve[0].value)
+        curveIndex = 1
+        while curveIndex < len(track.Curve):
+            curve = track.Curve[curveIndex]
+            preCurve = track.Curve[curveIndex - 1]
+            if (abs(curve.time - preCurve.time - 0.01) < 0.0001): 
+                nextCurve = track.Curve[curveIndex + 1]
+                if (nextCurve.value == curve.value):
+                    segments.append(3) # InverseSteppedSegment
+                    segments.append(nextCurve.time)
+                    segments.append(nextCurve.value)
+                    motion['Meta']['TotalPointCount'] += 1
+                    motion['Meta']['TotalSegmentCount'] += 1
+                    curveIndex += 1
+                    continue
+            if (curve.inSlope == float('+inf')):
+                segments.append(2) # SteppedSegment
+                segments.append(curve.time)
+                segments.append(curve.value)
+                motion['Meta']['TotalPointCount'] += 1
+            elif (preCurve.outSlope == 0 and abs(curve.inSlope) < 0.0001):
+                segments.append(0) # LinearSegment
+                segments.append(curve.time)
+                segments.append(curve.value)
+                motion['Meta']['TotalPointCount'] += 1
+            else:
+                tangentLength = (curve.time - preCurve.time) / 3
+                segments.append(1) # BezierSegment
+                segments.append(preCurve.time + tangentLength)
+                segments.append(preCurve.outSlope * tangentLength + preCurve.value)
+                segments.append(curve.time - tangentLength)
+                segments.append(curve.value - curve.inSlope * tangentLength)
+                segments.append(curve.time)
+                segments.append(curve.value)
+                motion['Meta']['TotalPointCount'] += 3
+            motion['Meta']['TotalSegmentCount'] += 1
+            curveIndex+=1
+        path = track.Path
+        if path in pathTable:
+            target, id = pathTable[path].split('/')
+            if target == 'Parameters': target = 'Parameter'
+            if target == 'Parts': target = 'PartOpacity'
+        else:
+            logger.warning('Failed to bind path CRC %s to any Live2D path' % path)
+            target,id = 'PartOpacity', str(path)
+        motion['Curves'].append(
+            {
+                'Target' : target,
+                'Id': id,
+                'Segments': segments
+            }
+        )    
+    for event in animationClip.m_Events:
+        motion['UserData'].append(
+            {
+                'time' : event.time,
+                'value': event.data
+            }
+        )
+        motion['Meta']['UserDataCount'] += 1
+        motion['Meta']['TotalUserDataSize'] += len(event.data)
+    return motion
+
+def main_live2dextract(args):
+    with open(args.infile,'rb') as f:
+        from UnityPy.enums import ClassIDType
+        makedirs(args.outdir,exist_ok=True)
+        env = load_assetbundle(f)
+        monobehaviors = dict()
+        textures = dict()
+        animations = dict()
+        for obj in env.objects:
+            data = obj.read()
+            if obj.type in {ClassIDType.MonoBehaviour}:
+                monobehaviors[data.name] = data
+            if obj.type in {ClassIDType.Texture2D}:
+                textures[data.name] = data
+            if obj.type in {ClassIDType.AnimationClip}:
+                animations[data.name] = data
+        modelData = monobehaviors.get('BuildModelData',None)
+        if not modelData:
+            logger.warning('BuildModelData absent. Not extracting Live2D models!')
+        else:
+            modelData = modelData.read_typetree()
+            # TextAssets are directly extracted
+            # Usually there are *.moc3, *.model3, *.physics3; the last two should be renamed to *.*.json
+            for obj in env.objects:
+                if obj.type == ClassIDType.TextAsset:
+                    data = obj.read()
+                    out_name : str = data.name
+                    if out_name.endswith('.moc3') or out_name.endswith('.model3') or out_name.endswith('.physics3'):
+                        if out_name.endswith('.model3') or out_name.endswith('.physics3'):
+                            out_name += '.json'
+                        with open(path.join(args.outdir, out_name),'wb') as fout:
+                            logger.info('Extracting Live2D Asset %s' % out_name)
+                            fout.write(data.script)
+            # Textures always needs conversion and is placed under specific folders
+            for texture in modelData['TextureNames']:
+                name = path.basename(texture)
+                folder = path.dirname(texture)
+                out_folder = path.join(args.outdir, folder)
+                makedirs(out_folder,exist_ok=True)
+                out_name = path.join(out_folder, name)
+                logger.info('Extracting Texture %s' % out_name)
+                name_wo_ext = '.'.join(name.split('.')[:-1])
+                textures[name_wo_ext].image.save(out_name)
+        # Animations are serialized into AnimationClip
+        if not args.no_anim:
+            from sssekai.unity.constant.SekaiLive2DPathNames import NAMES_CRC_TBL
+            for clipName, clip in animations.items():
+                logger.info('Extracting Animation %s' % clipName)
+                data = animation_clip_to_live2d_motion3(clip, NAMES_CRC_TBL)  
+                # https://til.simonwillison.net/python/json-floating-point
+                def round_floats(o):
+                    if isinstance(o, float):
+                        return round(o, 3)
+                    if isinstance(o, dict):
+                        return {k: round_floats(v) for k, v in o.items()}
+                    if isinstance(o, (list, tuple)):
+                        return [round_floats(x) for x in o]
+                    return o                       
+                json.dump(round_floats(data), open(path.join(args.outdir, clipName+'.motion3.json'),'w'), indent=4, ensure_ascii=False)
+        pass

sssekai/entrypoint/mitm.py

@@ -0,0 +1,7 @@
+import os,sys
+def main_mitm(args):
+    from mitmproxy.tools.main import mitmdump
+    current_dir = os.path.dirname(os.path.realpath(__file__))    
+    args = [*sys.argv[1:], '-s', '"%s"' % os.path.join(os.path.dirname(os.path.dirname(current_dir)),'mitmproxy_sekai_api.py')]
+    print('running mitmdump with args:', *args)
+    mitmdump(args=args)

sssekai/entrypoint/usmdemux.py

@@ -0,0 +1,32 @@
+from sssekai.crypto.AssetBundle import SEKAI_AB_MAGIC
+from sssekai.unity.AssetBundle import load_assetbundle
+
+from os import path,remove,makedirs
+def main_usmdemux(args):
+    from UnityPy.enums import ClassIDType
+    from wannacri.usm import Usm
+
+    with open(args.infile,'rb') as f:
+        env = load_assetbundle(f)    
+        datas = dict()
+        for obj in env.objects:
+            if obj.type in {ClassIDType.MonoBehaviour, ClassIDType.TextAsset}:
+                data = obj.read()
+                datas[data.name] = data    
+        movieInfo = datas.get('MovieBundleBuildData',None)
+        assert movieInfo, "Invalid AssetBundle. No MovieBundleBuildData found!"
+        movieInfo = movieInfo.read_typetree()
+        usm_name = movieInfo['movieBundleDatas'][0]['usmFileName'][:-len('.bytes')]
+        print('USM: %s' % usm_name)
+        usm_folder = path.join(args.outdir,usm_name)
+        makedirs(usm_folder,exist_ok=True)
+        usm_temp = path.join(usm_folder,usm_name + '.tmp')
+        with open(usm_temp,'wb') as usmstream:
+            for data in movieInfo['movieBundleDatas']:
+                usm = data['usmFileName'][:-len('.bytes')]
+                usm = datas[usm]
+                usmstream.write(usm.script)
+        usm = Usm.open(usm_temp,encoding='shift-jis')
+        usm.demux(path.join(args.outdir,usm_name),usm_name)
+        remove(usm_temp)
+        print('Saved to %s/' % usm_folder)

sssekai/fmt/moc3.py

@@ -0,0 +1,40 @@
+from typing import BinaryIO
+from struct import unpack
+
+# https://github.com/OpenL2D/moc3ingbird/blob/master/src/moc3.hexpat
+class moc3:    
+    Parameters : list
+    Parts: list
+    def __init__(self, file : BinaryIO) -> None:        
+        # Header: 64 bytes
+        file.seek(0)
+        assert file.read(4) == b'MOC3'
+        version = unpack('<c',file.read(1))[0]
+        isBigEndian = unpack('<b',file.read(1))[0]
+        assert not isBigEndian
+                
+        # TODO: Other fields
+        file.seek(0x40)
+        pCountInfo = unpack('<I',file.read(4))[0]
+        
+        file.seek(pCountInfo)
+        numParts = unpack('<I',file.read(4))[0]
+        file.seek(0x10, 1)
+        numParameters = unpack('<I',file.read(4))[0]
+
+        file.seek(0x4C)
+        pParts = unpack('<I',file.read(4))[0]
+
+        file.seek(0x108)
+        pParameters = unpack('<I',file.read(4))[0]
+        
+        def read_strings(offset, count):
+            for i in range(0,count):
+                file.seek(offset + i * 0x40)   
+                buffer = bytearray()  
+                while b := file.read(1)[0]:
+                    buffer.append(b)
+                yield buffer.decode(encoding='utf-8')
+        
+        self.Parts = list(read_strings(pParts,numParts))
+        self.Parameters = list(read_strings(pParameters,numParameters))