import sys


def main():
    if len(sys.argv) != 4:
        print(f"Usage: python {sys.argv[0]} <file1> <file2> <output>")
        raise SystemExit(1)

    file1, file2, output = sys.argv[1], sys.argv[2], sys.argv[3]
    chunk_size = 1024 * 1024

    with open(file1, "rb") as f1, open(file2, "rb") as f2, open(output, "wb") as out:
        while True:
            b1 = f1.read(chunk_size)
            b2 = f2.read(chunk_size)

            if not b1 or not b2:
                break

            n = min(len(b1), len(b2))
            out.write(bytes(x ^ y for x, y in zip(b1[:n], b2[:n])))


if __name__ == "__main__":
    main()

# key = [103,50,102,99,67,48,90,99,122,78,57,77,84,74,54,49]
# iv = [109,115,120,51,73,86,48,105,57,88,69,53,117,89,90,49]

key = b'g2fcC0ZczN9MTJ61'
iv = b'msx3IV0i9XE5uYZ1'

import json
import msgpack
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

# get key and iv from frida-il2cpp-bridge first
key = b'g2fcC0ZczN9MTJ61'
iv = b'msx3IV0i9XE5uYZ1'

def decrypt_aes_cbc(data: bytes) -> bytes:
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted_data = unpad(cipher.decrypt(data), AES.block_size)
    return decrypted_data

def encrypt_aes_cbc(data: bytes) -> bytes:
    cipher = AES.new(key, AES.MODE_CBC, iv)
    padded_data = pad(data, AES.block_size)
    encrypted_data = cipher.encrypt(padded_data)
    return encrypted_data

def encode_msgpack(data: dict) -> bytes:
    if data is None:
        raise ValueError("Input data for encode_msgpack cannot be None")
    packed = msgpack.packb(data, use_bin_type=True)
    if not isinstance(packed, bytes):
        raise TypeError("msgpack.packb did not return bytes")
    return packed

def decode_msgpack(data: bytes) -> dict:
    return msgpack.unpackb(data, raw=False)

def pjsk_encode_msgpack(data: dict) -> bytes:
    packed = encode_msgpack(data)
    encrypted = encrypt_aes_cbc(packed)
    return encrypted

def pjsk_decode_msgpack(data: bytes) -> dict:
    decrypted = decrypt_aes_cbc(data)
    decoded = decode_msgpack(decrypted)
    return decoded

# the more miku the better!
# author: [MetaMiku](https://github.com/MetaMikuAI)

from mitmproxy import http
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import msgpack
import json


# get key and iv from frida-il2cpp-bridge first
key = b'g2fcC0ZczN9MTJ61'
iv = b'msx3IV0i9XE5uYZ1'


target_url_list = [
    "https://production-game-api.sekai.colorfulpalette.org",
]


def decrypt_aes_cbc(data: bytes) -> bytes:
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted_data = unpad(cipher.decrypt(data), AES.block_size)
    return decrypted_data

def encrypt_aes_cbc(data: bytes) -> bytes:
    cipher = AES.new(key, AES.MODE_CBC, iv)
    padded_data = pad(data, AES.block_size)
    encrypted_data = cipher.encrypt(padded_data)
    return encrypted_data


def encode_msgpack(data: dict) -> bytes:
    if data is None:
        raise ValueError("Input data for encode_msgpack cannot be None")
    packed = msgpack.packb(data, use_bin_type=True)
    if not isinstance(packed, bytes):
        raise TypeError("msgpack.packb did not return bytes")
    return packed

def decode_msgpack(data: bytes) -> dict:
    return msgpack.unpackb(data, raw=False)


def dict_to_pretty_json(data: dict) -> str:
    return json.dumps(data, ensure_ascii=False, indent=2)


def pjsk_encrypt_msgpack(data: dict) -> bytes:
    packed = encode_msgpack(data)
    encrypted = encrypt_aes_cbc(packed)
    return encrypted


def pjsk_decrypt_msgpack(data: bytes) -> dict:
    decrypted = decrypt_aes_cbc(data)
    decoded = decode_msgpack(decrypted)
    return decoded


def hack_gacha_results(data: dict) -> dict:
    target_data = {
        "card": {
            "resourceId": 1235,
            "resourceType": "card",
            "resourceLevel": 1,
            "quantity": 1
        },
        "newFlg": False,
        "gachaLotteryType": "normal",
        "costume3d": [],
        "cardExtra": []
    }


    gacha_results = data["obtainPrizes"]
    for idx, result in enumerate(gacha_results):
        id = result["card"]["resourceId"]
        print(f"Gacha ID: {id}")
        gacha_results[idx] = target_data
    
    data["obtainPrizes"] = gacha_results
    return data

def request(flow: http.HTTPFlow) -> None: # type: ignore
    for target_url in target_url_list:
        print(flow.request.pretty_url)
        if flow.request.pretty_url.startswith(target_url):
            pass


def response(flow: http.HTTPFlow) -> None: # type: ignore
    for target_url in target_url_list:
        print(flow.request.pretty_url)
        if flow.request.pretty_url.startswith(target_url):
            if "gachaBehaviorId" in flow.request.pretty_url:
                original_data = pjsk_decrypt_msgpack(flow.response.content)
                modified_data = hack_gacha_results(original_data)
                re_encrypted = pjsk_encrypt_msgpack(modified_data)
                flow.response.content = re_encrypted

# mitmweb -m wireguard --no-http2 -s ./mitmproxy.py --set termlog_verbosity=info --ignore 127.0.0.1

from mitmproxy import http

LOG_FILE = "analyze_jwt.txt"

targets = [
    "https://production-game-api.sekai.colorfulpalette.org"
]

def request(flow: http.HTTPFlow) -> None:
    for target in targets:
        if flow.request.pretty_url.startswith(target):
            with open(LOG_FILE, "a") as f:
                f.write(f"Request: {flow.request.method} {flow.request.pretty_url}\n")
                if "X-Session-Token" in flow.request.headers:
                    f.write(f"X-Session-Token: {flow.request.headers['X-Session-Token']}\n")
                if flow.request.content:
                    if len(flow.request.content) == 16:
                        return

                    try:
                        data = pjsk_decode_msgpack(flow.request.content)
                        jwt_fields = detect_jwt_in_json(data)
                        if jwt_fields:
                            f.write("Detected JWT fields in JSON payload:\n")
                            f.write(json.dumps(jwt_fields, indent=2) + "\n")
                    except json.JSONDecodeError:
                        pass
                f.write("\n")

def response(flow: http.HTTPFlow) -> None:
    for target in targets:
        if flow.request.pretty_url.startswith(target):
            with open(LOG_FILE, "a") as f:
                f.write(f"Response: {flow.request.method} {flow.request.pretty_url}\n")
                if "X-Session-Token" in flow.response.headers:
                    f.write(f"X-Session-Token: {flow.response.headers['X-Session-Token']}\n")
                if flow.response.content:
                    if len(flow.request.content) == 16:
                        return
                    try:
                        data = pjsk_decode_msgpack(flow.response.content)
                        jwt_fields = detect_jwt_in_json(data)
                        if jwt_fields:
                            f.write("Detected JWT fields in JSON payload:\n")
                            f.write(json.dumps(jwt_fields, indent=2) + "\n")
                    except json.JSONDecodeError:
                        pass
                f.write("\n\n")

# 毕竟是临时的脚本, 嵌套多了一点就多一点吧 -- MetaMiku

def is_jwt(token: str) -> bool:
    parts = token.split('.')
    return len(parts) == 3 and all(part.isascii() for part in parts) and not parts[0].startswith('http') and len(token) > 32

def detect_jwt_in_json(data: dict) -> dict:
    jwt_fields = {}
    for key, value in data.items():
        if isinstance(value, str) and is_jwt(value):
            jwt_fields[key] = value
        elif isinstance(value, dict):
            nested_jwt = detect_jwt_in_json(value)
            if nested_jwt:
                jwt_fields[key] = nested_jwt
        elif isinstance(value, list):
            for item in value:
                if isinstance(item, dict):
                    nested_jwt = detect_jwt_in_json(item)
                    if nested_jwt:
                        jwt_fields[key] = nested_jwt
    return jwt_fields

from mitmproxy import http
from time import time
from crypto import prsk_dec, prsk_enc
import json
from random import randint


def request(flow: http.HTTPFlow) -> None:
    # /api/user/<userId>/live/<userLiveId>
    if "/api/user/" in flow.request.pretty_url and "/live/" in flow.request.pretty_url:
        if flow.request.content is None:
            return
        body = prsk_dec(flow.request.content)
        if "score" in body:
            body["score"] = randint(90000, 120000)
            body["life"] = 1000
            perfectCount = body["perfectCount"]
            greatCount = body["greatCount"]
            goodCount = body["goodCount"]
            badCount = body["badCount"]
            missCount = body["missCount"]
            maxCombo = body["maxCombo"]
            total = perfectCount + greatCount + goodCount + badCount + missCount
            body["perfectCount"] = total
            body["greatCount"] = 0
            body["goodCount"] = 0
            body["badCount"] = 0
            body["missCount"] = 0
            body["maxCombo"] = total
            body["tapCount"] = total*2 + randint(0, 100)
            flow.request.content = prsk_enc(body)
            print(f"Modified live data: {body}")

# Patch custom-profile-card
from mitmproxy import http
from crypto import prsk_dec, prsk_enc # type: ignore

target_image_b64 = None
assert target_image_b64 is not None, "Please set target_image_b64 variable"

def request(flow: http.HTTPFlow) -> None:
    if flow.request.method in ["POST", "PUT"] and "custom-profile-card" in flow.request.pretty_url:
        if flow.request.content is None:
            return
        request_data = prsk_dec(flow.request.content)
        request_data['thumbnail'] = target_image_b64
        flow.request.content = prsk_enc(request_data)

from mitmproxy import http
from base64 import b64encode
from crypto import prsk_dec, prsk_enc # type: ignore

target_dir_path = '~/prsk/test/patchimages/'


# POST/PUT https://production-game-api.sekai.colorfulpalette.org/api/user/{user_id}/custom-profile/1/custom-profile-card/{card_id}
def request(flow: http.HTTPFlow) -> None:
    if flow.request.method in ["POST", "PUT"] and "custom-profile-card" in flow.request.pretty_url:
        if flow.request.content is None:
            return
        card_id = flow.request.pretty_url.split("/")[-1]
        request_data = prsk_dec(flow.request.content)
        target_image_path = target_dir_path + str(card_id) + '.jpg'
        with open(target_image_path, 'rb') as f:
            image = f.read()

        request_data['thumbnail'] = b64encode(image).decode('utf-8')
        flow.request.content = prsk_enc(request_data)
        # print(request_data) # check the modified request data but not actually send it
        print(f"Replaced thumbnail for card_id {card_id} from {target_image_path}")