from capstone import Cs, CsInsn, CS_ARCH_X86, CS_MODE_64
from capstone.x86_const import *
from keystone import Ks, KS_ARCH_X86, KS_MODE_64
import lief

class Deobf:
    def __init__(self):
        self.bin: lief.PE.Binary = lief.parse("unpacked.exe")

        self.md = Cs(CS_ARCH_X86, CS_MODE_64)
        self.md.detail = True

        self.to_patch = []

    def is_xor_eax_eax(self, insn: CsInsn):
        if insn.id == X86_INS_XOR:
            operands = insn.operands
            if operands[0].type == X86_OP_REG and operands[1].type == X86_OP_REG:
                if operands[0].reg == operands[1].reg:
                    return True
        return False

    def deobf(self, sa: int, ea: int):
        bin = bytes(self.bin.get_content_from_virtual_address(sa, ea-sa))

        ptr = sa
        is_pattern = False
        while (ptr < ea):
            # print(hex(ptr))
            if is_pattern == False:
                for insn in self.md.disasm(bin[ptr-sa:ptr-sa+0x20], ptr, 1):
                    if self.is_xor_eax_eax(insn):
                        is_pattern = True
                    ptr += insn.size
            else:
                for insn in self.md.disasm(bin[ptr-sa:ptr-sa+0x20], ptr, 1):
                    if insn.id == X86_INS_JE:
                        operand = insn.operands[0]
                        assert operand.type == X86_OP_IMM
                        target = operand.imm
                        # print(hex(ptr), hex(target), hex(operand.imm))
                        self.to_patch.append((ptr, target))
                        ptr = target
                    else:
                        is_pattern = False
                        ptr += insn.size
        
        for a, b in self.to_patch:
            assert a < b
            new = [0x90 for _ in range(b - a)]
            try:
                self.bin.patch_address(a, new)
            except:
                print(a, b)
        
        builder = lief.PE.Builder(self.bin)
        builder.build()
        builder.write("patched.exe")
        return

if __name__ == "__main__":
    sa = 0x3D5AC
    ea = 0x6EDD7
    d = Deobf()
    d.deobf(sa, ea)

# get_data_flow.py
# - PE RVA 기준으로 Capstone 디스어셈블
# - call imm32 사이트를 찾고, call 직전 백워드 스캔으로 RCX/EDX 근원을 수집
# - EDX가 [rax(+disp)] 형태일 때, rax가 [rbp+arg_8]에서 올라온 뒤 add/sub/lea로 이동한 누적 오프셋을 반영
# - call 직후 ret 저장 mov [rbp+disp], eax/rax 를 찾아 ret_store로 기록
# - 결과를 out/call_sites.json, out/hook_targets.json(RVA만)으로 저장

from __future__ import annotations
import json
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

import lief
from capstone import Cs, CS_ARCH_X86, CS_MODE_64
from capstone.x86_const import *

# ========== 유틸 ==========
def hx(n: int) -> str:
    return f"0x{n:x}"

def is_call_imm(insn) -> bool:
    return insn.id == X86_INS_CALL and insn.operands and insn.operands[0].type == X86_OP_IMM

def get_mem_rbp_disp(op) -> Optional[int]:
    if op.type != X86_OP_MEM:
        return None
    m = op.mem
    if m.base == X86_REG_RBP and m.index == X86_REG_INVALID:
        return m.disp
    return None

def is_mov_reg_mem(insn, dst_reg) -> Optional[int]:
    # mov dst_reg, [rbp+disp]
    if insn.id != X86_INS_MOV or len(insn.operands) != 2:
        return None
    dst, src = insn.operands
    if dst.type == X86_OP_REG and dst.reg == dst_reg:
        disp = get_mem_rbp_disp(src)
        if disp is not None:
            return disp
    return None

def is_mov_reg_reg(insn, dst_reg, src_regs: Tuple[int, ...]) -> bool:
    if insn.id != X86_INS_MOV or len(insn.operands) != 2:
        return False
    dst, src = insn.operands
    return dst.type == X86_OP_REG and dst.reg == dst_reg and src.type == X86_OP_REG and src.reg in src_regs

def is_mov_reg_imm(insn, dst_reg) -> Optional[int]:
    if insn.id != X86_INS_MOV or len(insn.operands) != 2:
        return None
    dst, src = insn.operands
    if dst.type == X86_OP_REG and dst.reg == dst_reg and src.type == X86_OP_IMM:
        return src.imm
    return None

def is_add_reg_imm(insn, reg) -> Optional[int]:
    if insn.id != X86_INS_ADD or len(insn.operands) != 2:
        return None
    dst, src = insn.operands
    if dst.type == X86_OP_REG and dst.reg == reg and src.type == X86_OP_IMM:
        return src.imm
    return None

def is_sub_reg_imm(insn, reg) -> Optional[int]:
    if insn.id != X86_INS_SUB or len(insn.operands) != 2:
        return None
    dst, src = insn.operands
    if dst.type == X86_OP_REG and dst.reg == reg and src.type == X86_OP_IMM:
        return src.imm
    return None

def is_lea_rax_rax_plus_imm(insn) -> Optional[int]:
    # lea rax, [rax+imm]
    if insn.id != X86_INS_LEA or len(insn.operands) != 2:
        return None
    dst, src = insn.operands
    if dst.type == X86_OP_REG and dst.reg == X86_REG_RAX and src.type == X86_OP_MEM:
        m = src.mem
        if m.base == X86_REG_RAX and m.index == X86_REG_INVALID:
            return m.disp
    return None

def is_mov_mem_eax_or_rax(insn) -> Optional[int]:
    # mov [rbp+disp], eax/rax
    if insn.id != X86_INS_MOV or len(insn.operands) != 2:
        return None
    dst, src = insn.operands
    disp = get_mem_rbp_disp(dst)
    if disp is not None and src.type == X86_OP_REG and src.reg in (X86_REG_EAX, X86_REG_RAX):
        return disp
    return None

def is_mov_edx_from_rax_mem(insn) -> Optional[int]:
    # mov edx, [rax + disp]   (disp 0 포함)
    if insn.id != X86_INS_MOV or len(insn.operands) != 2:
        return None
    dst, src = insn.operands
    if not (dst.type == X86_OP_REG and dst.reg == X86_REG_EDX):
        return None
    if src.type != X86_OP_MEM:
        return None
    m = src.mem
    if m.base != X86_REG_RAX or m.index != X86_REG_INVALID:
        return None
    return m.disp

# ========== 파서 ==========
class Parser:
    def __init__(self, bin_path: str):
        self.bin: lief.PE.Binary = lief.parse(bin_path)
        self.imgbase: int = int(self.bin.optional_header.imagebase)
        self.md = Cs(CS_ARCH_X86, CS_MODE_64)
        self.md.detail = True

    def parse(self, sa_rva: int, ea_rva: int) -> List[Dict[str, Any]]:
        """[sa_rva, ea_rva) 범위를 RVA 기준으로 디스어셈블하여 call 사이트 수집"""
        code = bytes(self.bin.get_content_from_virtual_address(sa_rva, ea_rva - sa_rva))
        # Capstone 기준주소 = RVA (VA 사용하지 않음)
        insns = list(self.md.disasm(code, sa_rva))
        results: List[Dict[str, Any]] = []

        n = len(insns)
        BACK_WINDOW = 8  # 여유 있게

        i = 0
        while i < n:
            insn = insns[i]
            if not is_call_imm(insn):
                i += 1
                continue

            call_rva = insn.address            # RVA
            target_rva = insn.operands[0].imm  # RVA (Capstone가 기준에 맞춰 계산해줌)

            # call 직후 한 명령: mov [rbp+disp], eax/rax → ret_store
            ret_store_disp: Optional[int] = None
            if i + 1 < n:
                ret_store_disp = is_mov_mem_eax_or_rax(insns[i + 1])

            # ----- 백워드 데이터 플로우 -----
            rcx_src: Optional[str] = None
            rdx_src: Optional[str] = None

            # RAX 오프셋 선누적용
            last_rax_kind: Optional[str] = None  # "arg8" 등 (mov rax,[rbp+...])
            last_rax_add: int = 0                # add/sub/lea 누적

            # RCX가 EAX에 의존하는지 표시
            pending_rcx_from_eax = False
            last_eax_from_mem_disp: Optional[int] = None

            # ★ RDX 지연 확정용 버퍼
            rdx_from_rax_disp: Optional[int] = None   # mov edx,[rax+disp]에서의 disp를 보관

            j = i - 1
            steps = 0
            while j >= 0 and steps < BACK_WINDOW and (rcx_src is None or rdx_src is None or rdx_from_rax_disp is not None):
                pj = insns[j]

                # (1) RAX에 대한 add/sub/lea는 선누적
                add_imm = is_add_reg_imm(pj, X86_REG_RAX)
                if add_imm is not None:
                    last_rax_add += add_imm
                else:
                    sub_imm = is_sub_reg_imm(pj, X86_REG_RAX)
                    if sub_imm is not None:
                        last_rax_add -= sub_imm
                    else:
                        lea_off = is_lea_rax_rax_plus_imm(pj)
                        if lea_off is not None:
                            last_rax_add += lea_off
                        else:
                            # (2) RAX 베이스 정의: mov rax, [rbp+disp]
                            disp_arg8 = is_mov_reg_mem(pj, X86_REG_RAX)
                            if disp_arg8 is not None:
                                last_rax_kind = "arg8"

                # (3) RDX 근원 (즉시 확정하지 말고 의존성만 기록)
                if rdx_src is None:
                    imm = is_mov_reg_imm(pj, X86_REG_EDX)
                    if imm is not None:
                        rdx_src = f"imm:{imm & 0xFFFFFFFF:#x}"
                    else:
                        disp_edx = is_mov_reg_mem(pj, X86_REG_EDX)
                        if disp_edx is not None:
                            rdx_src = f"[rbp{disp_edx:+#x}]"
                        else:
                            disp_from_rax = is_mov_edx_from_rax_mem(pj)
                            if disp_from_rax is not None:
                                # ★ 여기서는 문자열 만들지 말고 DISP만 저장
                                rdx_from_rax_disp = disp_from_rax

                # (4) RCX 근원 (기존 로직 그대로)
                if rcx_src is None:
                    disp_ecx = is_mov_reg_mem(pj, X86_REG_ECX)
                    if disp_ecx is not None:
                        rcx_src = f"[rbp{disp_ecx:+#x}]"
                        pending_rcx_from_eax = False
                    else:
                        if is_mov_reg_reg(pj, X86_REG_ECX, (X86_REG_EAX, X86_REG_RAX)):
                            if last_eax_from_mem_disp is not None:
                                rcx_src = f"[rbp{last_eax_from_mem_disp:+#x}]"
                            else:
                                pending_rcx_from_eax = True
                        else:
                            disp_eax = is_mov_reg_mem(pj, X86_REG_EAX)
                            if disp_eax is not None:
                                last_eax_from_mem_disp = disp_eax
                                if pending_rcx_from_eax and rcx_src is None:
                                    rcx_src = f"[rbp{disp_eax:+#x}]"
                                    pending_rcx_from_eax = False

                j -= 1
                steps += 1

            # ★★★ 루프가 끝난 뒤, RDX를 최종 확정 ★★★
            if rdx_src is None and rdx_from_rax_disp is not None:
                if last_rax_kind == "arg8":
                    total = last_rax_add + rdx_from_rax_disp
                    rdx_src = f"[[rbp+arg_8] + {total:#x}]"
                else:
                    rdx_src = f"[rax{rdx_from_rax_disp:+#x}]"

            entry = {
                "pattern": "GEN" if (rcx_src and rdx_src and ret_store_disp is not None) else None,
                "call_insn_rva": hx(call_rva),
                "call_target_rva": hx(target_rva),
                "args": {"rcx": rcx_src, "rdx": rdx_src},
                "ret_store": f"[rbp{ret_store_disp:+#x}]" if ret_store_disp is not None else None,
            }
            results.append(entry)
            i += 1

        return results

    def save_json(self, results: List[Dict[str, Any]], outdir: str = "out"):
        out = Path(outdir)
        out.mkdir(parents=True, exist_ok=True)

        # 1) call_sites.json — 모든 콜 사이트
        (out / "call_sites.json").write_text(json.dumps(results, indent=2), encoding="utf-8")

        # 2) hook_targets.json — 고유 타깃 + 해당 콜 사이트 rva
        targets: Dict[str, Dict[str, Any]] = {}
        for r in results:
            trva = r["call_target_rva"]
            if trva is None:
                continue
            if trva not in targets:
                targets[trva] = {"call_target_rva": trva, "call_sites_rva": []}
            targets[trva]["call_sites_rva"].append(r["call_insn_rva"])

        # 중복 제거 + 정렬
        for t in targets.values():
            s = sorted(set(t["call_sites_rva"]), key=lambda x: int(x, 16))
            t["call_sites_rva"] = s

        (out / "hook_targets.json").write_text(json.dumps(list(targets.values()), indent=2), encoding="utf-8")

# ========== 단독 실행 예시 ==========
if __name__ == "__main__":
    BIN = "patched.exe"
    SA  = 0x3D5AC
    EA  = 0x6EDD7

    P = Parser(BIN)
    res = P.parse(SA, EA)
    P.save_json(res, outdir="out")
    print("[+] saved: out/call_sites.json, out/hook_targets.json (RVA only)")

import json
from pathlib import Path
from typing import Dict, List

def get_func_call():
    TRACE_PATH = Path("out/trace.json")
    REPEAT_N = 6  # 반복 가설

    def _to_int(x):
        if isinstance(x, int):
            return x
        s = str(x).strip().lower()
        if s.startswith("0x"):
            return int(s, 16)
        # 혹시 "fae5" 같은 순수 hex 문자열이면:
        try:
            return int(s, 16)
        except ValueError:
            return int(s)  # 마지막 방어: 10진

    data = json.loads(TRACE_PATH.read_text(encoding="utf-8"))

    # seq 기준 정렬 후 target_rva만 int로 추출
    seq_targets: list[int] = [_to_int(r["target_rva"]) for r in sorted(data, key=lambda r: int(r["seq"]))]

    # 12등분 반복 여부 검사
    n = len(seq_targets)
    is_repeated = (n % REPEAT_N == 0)
    seq_targets_dedup: list[int] | None = None

    if is_repeated:
        chunk = n // REPEAT_N
        first = seq_targets[:chunk]
        is_repeated = all(seq_targets[i*chunk:(i+1)*chunk] == first for i in range(REPEAT_N))
        if is_repeated:
            seq_targets_dedup = first

    print(f"[info] total calls = {n}, divisible by {REPEAT_N}: {n % REPEAT_N == 0}")
    print(f"[info] exact {REPEAT_N}x repetition: {is_repeated}")
    if is_repeated:
        print(f"[info] dedup length = {len(seq_targets_dedup)}")
    
    return seq_targets

from capstone import Cs, CsInsn, CS_ARCH_X86, CS_MODE_64
from capstone.x86_const import *
import lief

def parse_handler(hook_targets):
    bin: lief.PE.Binary = lief.parse("patched.exe")
    md = Cs(CS_ARCH_X86, CS_MODE_64)
    md.detail = True

    for target in hook_targets:
        target_addr = int(target["call_target_rva"], 0)
        code = bytes(bin.get_content_from_virtual_address(target_addr, 0x100))

        for insn in md.disasm(code[0x25:], target_addr+0x25, count=1):
            assert insn.id == X86_INS_JE
            operand = insn.operands[0]
            next = operand.imm + 0x1f

        for insn in md.disasm(code[next-target_addr:], next, count=1):
            asm_str = insn.mnemonic + " " + insn.op_str
            if asm_str == "and rax, rdx":
                target["op"] = "&"
            elif asm_str == "xor rax, rdx":
                target["op"] = "^"
            elif asm_str == "mov r8, rdx":
                target["op"] = "*"
            elif asm_str == "add rax, rdx":
                target["op"] = "+"
            elif asm_str == "or rax, rdx":
                target["op"] = "|"
            elif asm_str == "mov cl, dl":
                if code[next-target_addr + 0xB - 0x7] == 0xE0:
                    target["op"] = "<<"
                elif code[next-target_addr + 0x2B - 0x27] == 0xE8:
                    target["op"] = ">>"
                else:
                    print(hex(insn.address), code[next-target_addr + 0xB - 0x7])
            elif asm_str == "sub rax, rdx":
                target["op"] = "-"
            elif asm_str == "mov rbx, rdx":
                target["op"] = "%"
            else:
                print(hex(insn.address))
    return

def parse_src(a):
    if "[" in a:
        mem = a[1:4]
        if mem == "rbp":
            offset = int(a[5:-1], 0)
            return f"D[{(0x160 - offset) // 4}]"
        elif mem == "rax":
            offset = int(a[7:-1], 0)
            return f"a[{offset // 4}]"
        else:
            print(a)
            exit()
    elif "imm:" in a:
        return a[4:]
    else:
        print(a)
        exit()

def parse_dst(a):
    if "[" in a:
        offset = int(a[5:-1], 0)
        mem = a[1:4]
        if mem == "rbp":
            return f"D[{(0x160 - offset) // 4}]"
        else:
            print("dst", a)
            exit()
    else:
        print("dst", a)
        exit()

def main():
    HOOK_PATH = Path("out/call_sites.json")

    handlers: List[dict] = json.loads(HOOK_PATH.read_text(encoding="utf-8"))

    parse_handler(handlers)

    with open("code.txt", "w") as f:
        f.write("")

    seq_targets = get_func_call()
    for idx, seq in enumerate(seq_targets):
        if idx >= len(seq_targets) // 6:
            break
        item = next(d for d in handlers if d.get("call_target_rva") == hex(seq))
        src1, src2 = parse_src(item["args"]["rcx"]), parse_src(item["args"]["rdx"])
        dst = parse_dst(item["ret_store"])
        op = item["op"]

        code = " ".join([dst, "=", src1, op, src2])
        with open("code.txt", "a") as f:
            f.write(code + "\n")
        

if __name__ == "__main__":
    main()

D[5] = D[8] % 0x7
D[4] = D[8] * 0xcb497beb
D[3] = D[3] - D[4]
D[6] = D[8] % 0x4
D[5] = D[2] << D[5]
D[6] = D[2] >> D[6]
D[5] = D[5] ^ a[3]
D[6] = D[6] ^ a[0]
D[7] = D[2] & D[3]
D[6] = D[6] ^ D[7]
D[5] = D[5] ^ D[6]
D[1] = D[1] - D[5]
D[5] = D[8] % 0x5
D[6] = D[8] % 0x6
D[5] = D[1] >> D[5]
D[6] = D[1] << D[6]
D[5] = D[5] ^ a[1]
D[6] = D[6] ^ a[2]
D[7] = D[1] | D[3]
D[6] = D[6] ^ D[7]
D[5] = D[5] ^ D[6]
D[2] = D[2] + D[5]
D[8] = D[8] + 0x1
D[6] = D[8] % 0x4
D[4] = D[8] * 0x522e687e
D[5] = D[8] % 0x7
D[3] = D[3] - D[4]
D[5] = D[2] << D[5]
D[6] = D[2] >> D[6]
D[5] = D[5] ^ a[3]
D[6] = D[6] ^ a[0]
D[7] = D[2] & D[3]
D[6] = D[6] ^ D[7]
D[5] = D[5] ^ D[6]
D[1] = D[1] - D[5]
D[5] = D[8] % 0x5
D[6] = D[8] % 0x6
D[5] = D[1] >> D[5]
D[6] = D[1] << D[6]
D[5] = D[5] ^ a[1]
D[6] = D[6] ^ a[2]
D[7] = D[1] | D[3]
D[6] = D[6] ^ D[7]
D[5] = D[5] ^ D[6]
D[2] = D[2] + D[5]
D[8] = D[8] + 0x1
D[4] = D[8] * 0x2abd81bc
D[6] = D[8] % 0x4
D[5] = D[8] % 0x7
D[3] = D[3] - D[4]
D[5] = D[2] << D[5]
D[6] = D[2] >> D[6]
D[5] = D[5] ^ a[3]
D[6] = D[6] ^ a[0]
D[7] = D[2] & D[3]
D[6] = D[6] ^ D[7]
D[5] = D[5] ^ D[6]
...

# decrypt_from_code_txt.py
import re
from typing import List, Tuple

MASK64 = (1 << 32) - 1

def u64(x: int) -> int:
    return x & MASK64

# ---------- 파서 ----------

ROUND_LINES = 23

K_RE   = re.compile(r"D\[\s*4\s*\]\s*=\s*D\[\s*8\s*\]\s*\*\s*(0x[0-9a-fA-F]+)")
MASK_RE = re.compile(r"a\[\s*(\d+)\s*\]")

def parse_rounds_from_code(path: str):
    """
    code.txt를 읽어 23줄씩 끊어 라운드별로
    - K (int)
    - masks (F_left, F_right, G_left, G_right) as tuple[int,int]
      * 라운드 내 등장하는 a[·] 4개를 순서대로 매핑
    를 리스트로 반환.
    """
    with open(path, "r", encoding="utf-8") as f:
        lines = [ln.rstrip("\n") for ln in f]

    if len(lines) % ROUND_LINES != 0:
        raise ValueError(f"총 줄수({len(lines)})가 23의 배수가 아님. 라운드 경계가 어긋났을 수 있습니다.")

    rounds = []
    for r in range(0, len(lines), ROUND_LINES):
        block = lines[r:r+ROUND_LINES]

        # 1) K 추출 (D[4] = D[8] * 0x........)
        K_vals = []
        for ln in block:
            m = K_RE.search(ln)
            if m:
                K_vals.append(int(m.group(1), 16))
        if len(K_vals) != 1:
            raise ValueError(f"{r//ROUND_LINES}번째 라운드: K 상수 발견 수 = {len(K_vals)} (기대: 1).")
        K = K_vals[0]

        # 2) 마스크 4개 추출 (등장 순서 그대로)
        mask_idxs = [int(s) for s in MASK_RE.findall("\n".join(block))]
        if len(mask_idxs) != 4:
            raise ValueError(f"{r//ROUND_LINES}번째 라운드: a[·] 마스크 등장 수 = {len(mask_idxs)} (기대: 4).")
        F_left, F_right, G_left, G_right = mask_idxs

        rounds.append({
            "K": K,
            "masks": (F_left, F_right, G_left, G_right),
        })
    return rounds

# ---------- 라운드 수학 ----------

def inverse_one_round(
    D: List[int],
    a_vals: List[int],
    i: int,
    K: int,
    masks: Tuple[int, int, int, int],
):
    """
    한 라운드를 '역방향'으로 되돌린다.
    - 현재 상태는 라운드 i가 끝난 시점(즉, 정방향으로 i를 막 수행한 직후)이라고 가정
    - 수행 후 상태는 라운드 i 시작 직전 상태로 바뀜

    라운드 규칙(정방향 요약):
      D3 -= i*K
      F = (D2 << (i%7)) ^ (D2 >> (i%4)) ^ (D2 & D3) , 단 중간에 a마스크가 좌/우에 섞여 반영됨
      D1 -= F
      G = (D1 >> (i%5)) ^ (D1 << (i%6)) ^ (D1 | D3) , 단 중간에 a마스크가 좌/우에 섞여 반영됨
      D2 += G
      D8 = i+1
    역방향 절차(현재 D8 == i+1 상태에서 시작):
      1) D2 = D2 - G
      2) D1 = D1 + F
      3) D3 = D3 + i*K
      4) D8 = i
    """
    # 시프트 상수
    r7 = i % 7
    r4 = i % 4
    r5 = i % 5
    r6 = i % 6

    F_L, F_R, G_L, G_R = masks

    # --- Step 1: D2 -= G ---
    # U1 = (D1 >> r5) ^ a[G_L]
    # U2 = (D1 << r6) ^ a[G_R];  U2 ^= (D1 | D3)
    U1 = u64(D[1] >> r5) ^ u64(a_vals[G_L])
    U2 = u64(D[1] << r6) ^ u64(a_vals[G_R])
    U2 ^= (D[1] | D[3]) & MASK64
    G  = U1 ^ U2
    D[2] = u64(D[2] - G)

    # --- Step 2: D1 += F ---
    # T1 = (D2 << r7) ^ a[F_L]
    # T2 = (D2 >> r4) ^ a[F_R];  T2 ^= (D2 & D3)
    T1 = u64(D[2] << r7) ^ u64(a_vals[F_L])
    T2 = u64(D[2] >> r4) ^ u64(a_vals[F_R])
    T2 ^= (D[2] & D[3]) & MASK64
    F  = T1 ^ T2
    D[1] = u64(D[1] + F)

    # --- Step 3: D3 += i*K ---
    D[3] = u64(D[3] + u64(i * (K & MASK64)))

    # --- Step 4: D8 = i ---
    D[8] = u64(i)

def compute_terminal_D3_D8(
    D3_init: int,
    D8_init: int,
    round_info: List[dict],
) -> Tuple[int, int]:
    """
    초기 D3,D8과 라운드 K들을 알고 있을 때,
    정방향으로 모두 돈 '종료 시점'의 (D3_final, D8_final)을 계산한다.
    (메시지/데이터와 무관)
    """
    D3 = u64(D3_init)
    i = u64(D8_init)
    for r in range(len(round_info)):
        K = round_info[r]["K"]
        D3 = u64(D3 - u64(i * (K & MASK64)))
        i  = u64(i + 1)
    return D3, i  # (D3_final, D8_final)

def decrypt_with_code(
    code_path: str,
    a_vals: List[int],     # 예: [a0, a1]
    D_init: dict,          # {"D1":final, "D2":final, "D3":init, "D8":init}  + (원하면 D3~D8 전부)
) -> List[int]:
    """
    code.txt를 파싱해 역산으로 평문(D1,D2)을 복원한다.
    인자:
      - code_path: code.txt 경로
      - a_vals: a 배열 실제 값들 (최소 2개: a[0], a[1])
      - D_init:
          필수: D1(최종), D2(최종), D3(초기), D8(초기)
          선택: D4,D5,D6,D7(초기)도 넣을 수 있으나 없어도 됨(0으로 채움)
    반환: 최종 복호 결과의 D 배열(0..8)
    """
    rounds = parse_rounds_from_code(code_path)
    N = len(rounds)

    # D 배열 준비
    D = [0] * 9
    # 최종 암문 상태에서 시작하므로 D1,D2는 '최종값'을 사용
    D[1] = u64(D_init.get("D1", 0))
    D[2] = u64(D_init.get("D2", 0))

    # D3..D8 초기값 입력
    D[3] = u64(D_init.get("D3", 0))
    D[4] = u64(D_init.get("D4", 0))
    D[5] = u64(D_init.get("D5", 0))
    D[6] = u64(D_init.get("D6", 0))
    D[7] = u64(D_init.get("D7", 0))
    D[8] = u64(D_init.get("D8", 0))

    # 정방향을 모두 수행했을 때의 (D3_final, D8_final)을 계산해서
    # 역산 시작 직전의 D3,D8으로 세팅
    D3_final, D8_final = compute_terminal_D3_D8(D[3], D[8], rounds)
    D[3] = D3_final
    D[8] = D8_final

    # 뒤에서 앞으로 역라운드
    # 라운드 인덱스 i는 D8-1, D8-2, ..., D8-N 순으로
    for r in range(N-1, -1, -1):
        i = u64(D[8] - 1)        # 현재는 (i+1)이 저장되어 있으므로 하나 내린 값이 라운드 인덱스
        K = rounds[r]["K"]
        F_L, F_R, G_L, G_R = rounds[r]["masks"]
        inverse_one_round(D, a_vals, i, K, (F_L, F_R, G_L, G_R))
        # 이제 D8은 i로 바뀐 상태

    # 여기서 D1,D2가 복호 결과(평문) 상태
    return D

MASK32 = (1 << 32) - 1

def _swap16_in_32(x: int) -> int:
    """32비트 값에서 상/하위 16비트를 맞바꿈: [b0,b1,b2,b3] -> [b2,b3,b0,b1]."""
    x &= MASK32
    return ((x << 16) | (x >> 16)) & MASK32  # ROR/ROL 16과 동치

def shuffle32_list(vals: List[int]) -> List[int]:
    """
    입력: [v0, v1, ...] 각 vi는 4바이트(0..0xFFFFFFFF) 정수
    출력: 각 vi에 대해 [b0,b1,b2,b3] -> [b2,b3,b0,b1] 셔플 적용
    """
    return [_swap16_in_32(v) for v in vals]

def unshuffle32_list(vals: List[int]) -> List[int]:
    """
    역산: 본 셔플은 자기 자신의 역연산(두 번 적용하면 원복)
    """
    return [_swap16_in_32(v) for v in vals]

# ---------- 예시 실행 ----------
if __name__ == "__main__":
    # 경로

    d = [0xEC6185B2, 0xD47844B8, 0x00EB9EE7, 0x17C6A398, 0xF6CF87F7, 0x04AE0512, 0xA7F53F10, 0x6A1A83DB, 0x9F52BFEF, 0xC933183C, 0x9830FD51, 0xAB852172]
    d = unshuffle32_list(d)
    print(d)

    CODE_PATH = "code.txt"  # 필요 시 수정

    # a 배열 값 예시 (사용자가 실제 값을 입력)
    a_vals = [
        0xB4B3522E,  # a[0]
        0x23DDF732,  # a[1]
        0x14C23B21,
        0xF3F3ACB4
    ]

    # 초기 D3..D8, 그리고 최종 D1,D2(암문 상태) 입력 예시
    # (사용자 환경에 맞게 수정)
    flag = []
    f = b""
    for i in range(6):
        D_init = {
            "D1": d[2*i],   # 최종 D1 (암문 상태)
            "D2": d[2*i+1],   # 최종 D2 (암문 상태)
            "D3": 0x12345679,   # 초기 D3
            "D4": 0,                    # 초기 스크래치는 0으로 두어도 무방
            "D5": 0,
            "D6": 0,
            "D7": 0,
            "D8": 0,                    # 초기 라운드 인덱스
        }

        D_out = decrypt_with_code(CODE_PATH, a_vals, D_init)

        flag.append(D_out[1])
        flag.append(D_out[2])
        f += D_out[1].to_bytes(4, "little") + D_out[2].to_bytes(4, "little")
        # print("[*] Decrypt done.")
        # print(f"D1 (plain?) = 0x{D_out[1]:016X}")
        # print(f"D2 (plain?) = 0x{D_out[2]:016X}")
        # print(f"D3          = 0x{D_out[3]:016X}")
        # print(f"D8          = 0x{D_out[8]:016X}")
    
    print(flag)
    a = b""
    for e in flag:
        a += e.to_bytes(4, "little")
    print(a)
    flag = shuffle32_list(flag)
    print(flag)
    a = b""
    for e in flag:
        a += e.to_bytes(4, "little")
    print(a)
    # flag = unshuffle32_list(flag)
    print(f)