import sys

def parse_vcd(filename):
    """
    Parse VCD and return list of (time_ns, value)
    Only parse lines like '0d' or '1d'
    """
    events = []
    cur_time = 0

    with open(filename, "r") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue

            if line.startswith("#"):
                cur_time = int(line[1:])
            elif line.endswith("d") and (line[0] == '0' or line[0] == '1'):
                # Only parse '0d' or '1d'
                val = int(line[0])
                events.append((cur_time, val))
            else:
                # Ignore $end, $var, etc.
                continue

    return events


def estimate_bit_time(events):
    """
    Estimate UART bit time by finding shortest stable pulse
    """
    durations = []
    for i in range(1, len(events)):
        dt = events[i][0] - events[i - 1][0]
        if dt > 0:
            durations.append(dt)

    durations.sort()
    short = durations[:10]  # shortest 10 transitions
    bit_time = sum(short) // len(short)
    return bit_time


def decode_uart(events, bit_time):
    """
    Decode UART frames from sampled events
    """
    decoded = []
    idx = 0
    cur_val = events[0][1]

    def sample(t):
        nonlocal idx, cur_val
        while idx + 1 < len(events) and events[idx + 1][0] <= t:
            idx += 1
            cur_val = events[idx][1]
        return cur_val

    t = events[0][0]
    end_time = events[-1][0]

    while t < end_time:
        # look for start bit (falling edge)
        if sample(t) == 1 and sample(t + bit_time // 2) == 0:
            t_start = t + bit_time

            byte = 0
            for i in range(8):
                bit = sample(t_start + i * bit_time + bit_time // 2)
                byte |= (bit << i)

            decoded.append(byte)

            # skip stop bit
            t = t_start + 9 * bit_time
        else:
            t += bit_time // 4

    return decoded


def main():
    if len(sys.argv) != 2:
        print("Usage: python vcd_uart_decode.py signal.vcd")
        sys.exit(1)

    filename = sys.argv[1]
    events = parse_vcd(filename)
    if not events:
        print("No events found in VCD!")
        sys.exit(1)

    bit_time = estimate_bit_time(events)
    baud = int(1e9 / bit_time)
    print(f"[+] Estimated bit time: {bit_time} ns")
    print(f"[+] Estimated baud rate: {baud}")

    data = decode_uart(events, bit_time)

    print("\n[+] UART bytes (hex):")
    print(" ".join(f"{b:02x}" for b in data))

    print("\n[+] ASCII:")
    for b in data:
        if 32 <= b <= 126:
            print(chr(b), end="")
        else:
            print(".", end="")
    print()


if __name__ == "__main__":
    main()

def rc4_decrypt(key, ciphertext):
    # 1. KSA (Key Scheduling Algorithm)
    S = list(range(256))
    j = 0
    key_bytes = [ord(c) for c in key]
    key_len = len(key_bytes)

    for i in range(256):
        j = (j + S[i] + key_bytes[i % key_len]) % 256
        S[i], S[j] = S[j], S[i]

    # 2. PRGA (Pseudo-Random Generation Algorithm) & XOR
    i = 0
    j = 0
    plaintext = []

    for char_code in ciphertext:
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]

        k = S[(S[i] + S[j]) % 256]
        plaintext.append(chr(char_code ^ k))

    return "".join(plaintext)

# 題目數據
key = "b4r3MEt41"
# 從 IDA 中 byte_394 提取的數據
cipher_data = [
    0xA2, 0xC3, 0x9E, 0xCC, 0x60, 0x35, 0xEE, 0xBF, 0xF5,
    0x7D, 0x78, 0x5A, 0xCD, 0xD5, 0xC8, 0x52, 0x80, 0xAE,
    0xC6, 0x19, 0x56, 0xF2, 0xA7, 0xCB, 0xD5, 0x0B, 0xE1,
    0x61, 0xB9, 0x14
]

flag = rc4_decrypt(key, cipher_data)
print(f"Flag: {flag}")

void encryptCode()
{
  PBYTE pBase = (PBYTE)((ULONGLONG)g_stcParam.dwImageBase + g_stcParam.lpStartVA);
  BYTE j;
  for (DWORD i = 0; i < g_stcParam.dwCodeSize; i++)
  {
    j = (BYTE)g_stcParam.pass[i % g_stcParam.passlen] + (BYTE)i;
    pBase[i] ^= j;
  }
}

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import re

# pip install z3-solver
from z3 import (
    BitVec, BitVecVal, ZeroExt, Solver,
    UGE, ULE, simplify, is_bv_value, sat
)

BUF = object()  # sentinel: "this register holds key buffer base ptr"


def strip_comment(line: str) -> str:
    return line.split(";", 1)[0].rstrip()


def parse_imm(tok: str) -> int:
    tok = tok.strip().rstrip(",")
    # hex like 0E9h / 1E8126h / 70h ...
    if tok.endswith(("h", "H")):
        return int(tok[:-1], 16)
    if tok.startswith(("0x", "0X")):
        return int(tok, 16)
    return int(tok, 10)


def bv32(n: int):
    return BitVecVal(n & 0xFFFFFFFF, 32)


def as_const_u32(expr):
    expr_s = simplify(expr)
    if is_bv_value(expr_s):
        return expr_s.as_long()
    return None


def extract_inst(line: str):
    line = strip_comment(line)
    if not line:
        return None

    m = re.search(r"\b(movzx|mov|imul|shl|add|cmp|lea|nop)\b", line)
    if not m:
        return None

    mnemonic = m.group(1)
    rest = line[m.end():].strip()
    ops = [o.strip() for o in rest.split(",")] if rest else []
    return mnemonic, ops


def parse_mem_byte(operand: str):
    # e.g. "byte ptr [ecx+eax]" / "[edx+ecx]"
    op = operand.replace(" ", "")
    m = re.search(r"\[(\w+)\+(\w+)\]", op)
    if not m:
        return None
    return m.group(1).lower(), m.group(2).lower()


def solve_from_asm(asm_text: str, printable=True):
    regs = {"eax": bv32(0), "ecx": bv32(0), "edx": bv32(0)}
    byte_vars = {}      # idx -> BitVec8
    constraints = []    # list[BoolRef]
    length = None       # from "cmp al, 0E9h"

    for raw_line in asm_text.splitlines():
        inst = extract_inst(raw_line)
        if not inst:
            continue

        mnem, ops = inst

        if mnem == "nop":
            continue

        if mnem == "lea":
            # treat lea reg, [ebp-80h] as "reg = BUF"
            if len(ops) >= 1 and ops[0].lower() in regs:
                regs[ops[0].lower()] = BUF
            continue

        if mnem == "mov":
            if len(ops) != 2:
                continue
            dst, src = ops[0].lower(), ops[1].strip()

            # ignore stores like "mov [ebp-8Ch], ecx"
            if dst.startswith("["):
                continue
            if dst not in regs:
                continue

            src_l = src.lower()
            if src_l.startswith("[ebp-8ch]"):
                regs[dst] = BUF
            elif src_l in regs:
                regs[dst] = regs[src_l]
            else:
                # immediate
                try:
                    regs[dst] = bv32(parse_imm(src))
                except ValueError:
                    pass
            continue

        if mnem == "movzx":
            if len(ops) != 2:
                continue
            dst = ops[0].lower()
            if dst not in regs:
                continue

            mem = parse_mem_byte(ops[1])
            if not mem:
                continue

            base, idx_reg = mem
            if base not in regs or idx_reg not in regs:
                continue
            if regs[base] is not BUF:
                continue
            if regs[idx_reg] is BUF:
                continue

            idx = as_const_u32(regs[idx_reg])
            if idx is None:
                raise RuntimeError(f"Non-constant index: {raw_line}")

            if idx not in byte_vars:
                byte_vars[idx] = BitVec(f"k_{idx:02X}", 8)

            regs[dst] = ZeroExt(24, byte_vars[idx])
            continue

        if mnem == "imul":
            # handle 3-operand imul: imul dst, src, imm
            if len(ops) != 3:
                continue
            dst, src, imm_s = ops[0].lower(), ops[1].lower(), ops[2]
            if dst not in regs or src not in regs:
                continue
            if regs[src] is BUF:
                raise RuntimeError(f"imul source is BUF? {raw_line}")
            imm = parse_imm(imm_s)
            regs[dst] = simplify(regs[src] * bv32(imm))
            continue

        if mnem == "shl":
            if len(ops) != 2:
                continue
            dst = ops[0].lower()
            if dst not in regs:
                continue
            if regs[dst] is BUF:
                raise RuntimeError(f"shl on BUF? {raw_line}")
            sh = parse_imm(ops[1])
            regs[dst] = simplify(regs[dst] << sh)
            continue

        if mnem == "add":
            if len(ops) != 2:
                continue
            dst, src = ops[0].lower(), ops[1].lower()
            if dst not in regs or src not in regs:
                continue
            if regs[dst] is BUF or regs[src] is BUF:
                raise RuntimeError(f"add with BUF? {raw_line}")
            regs[dst] = simplify(regs[dst] + regs[src])
            continue

        if mnem == "cmp":
            if len(ops) != 2:
                continue
            left, right = ops[0].lower(), ops[1]
            try:
                imm = parse_imm(right)
            except ValueError:
                continue

            if left == "al":
                length = imm
                continue

            if left in regs and regs[left] is not BUF:
                constraints.append(regs[left] == bv32(imm))
            continue

    s = Solver()

    # optional domain: printable ASCII
    for _, b in byte_vars.items():
        if printable:
            s.add(UGE(b, 0x20), ULE(b, 0x7E))

    for c in constraints:
        s.add(c)

    res = s.check()
    if res != sat:
        return length, None, byte_vars

    m = s.model()
    recovered = {idx: m.eval(var, model_completion=True).as_long()
                 for idx, var in byte_vars.items()}
    return length, recovered, byte_vars


def escaped_ascii(bs: bytes) -> str:
    out = []
    for x in bs:
        if 0x20 <= x <= 0x7E:
            out.append(chr(x))
        else:
            out.append(f"\\x{x:02x}")
    return "".join(out)


if __name__ == "__main__":
    ASM_TEXT = r"""
      Hacker:0042A752                 mov     edx, 1
      Hacker:0042A757                 imul    eax, edx, 0Dh
      Hacker:0042A75A                 mov     ecx, [ebp-8Ch]
      Hacker:0042A760                 movzx   edx, byte ptr [ecx+eax]
      把剩下的方程式全部貼進來
    """

    length, recovered, byte_vars = solve_from_asm(ASM_TEXT, printable=True)

    if recovered is None:
        print("[!] UNSAT / 解析失敗。你可以試試 printable=False，或確認 ASM_TEXT 是否完整。")
        raise SystemExit(1)

    print(f"[+] Found length (from cmp al, imm): {length} (hex: {length:#x})")
    print(f"[+] Solved {len(recovered)} byte positions: {sorted(recovered.keys())}")

    # dump solved bytes
    for idx in sorted(recovered):
        v = recovered[idx]
        ch = chr(v) if 0x20 <= v <= 0x7E else "."
        print(f"  key[{idx:02X}] = 0x{v:02X}  ({ch})")

    # build full candidate key
    if length is None:
        # fallback if you removed cmp al
        length = max(recovered.keys()) + 1

    key = bytearray(b"A" * length)
    for idx, v in recovered.items():
        if 0 <= idx < length:
            key[idx] = v

    print("\n[+] Candidate key (escaped):")
    print(escaped_ascii(bytes(key)))
    print("\n[+] Candidate key (hex):")
    print(key.hex())

#!/usr/bin/env python3
import struct

DELTA = 0x213B6EA8
N_WORDS = 0x0B  # 11 dwords => 44 bytes

# key table @ .data:004209DC (16 bytes = 4 dwords), little-endian
KEY_BYTES = bytes([
    0xA6, 0xB7, 0xB6, 0x0E,
    0x1E, 0x1D, 0x1E, 0x30,
    0xCD, 0xE2, 0x67, 0x1A,
    0xA6, 0xAC, 0x99, 0xC1,
])

def xxtea_variant_decrypt(ct: bytes, n_words: int = N_WORDS) -> bytes:
    size = n_words * 4
    ct = ct.ljust(size, b"\x00")[:size]

    v = list(struct.unpack("<%dI" % n_words, ct))
    k = list(struct.unpack("<4I", KEY_BYTES))

    n = n_words
    if n < 2:
        return ct

    q = 6 + (52 // n)
    s = (-q * DELTA) & 0xFFFFFFFF  # reverse start

    while q > 0:
        e = (s >> 2) & 3
        y = v[0]

        # p = n-1 .. 1
        for p in range(n - 1, 0, -1):
            z = v[p - 1]
            mx = (((z >> 5) ^ ((y << 2) & 0xFFFFFFFF)) +
                  ((y >> 3) ^ ((z << 4) & 0xFFFFFFFF))) & 0xFFFFFFFF
            mx ^= ((s ^ y) + (k[(p & 3) ^ e] ^ z)) & 0xFFFFFFFF

            v[p] = (v[p] - mx) & 0xFFFFFFFF
            y = v[p]

        # p = 0 (wrap uses z = v[n-1])
        z = v[n - 1]
        p = 0
        mx = (((z >> 5) ^ ((y << 2) & 0xFFFFFFFF)) +
              ((y >> 3) ^ ((z << 4) & 0xFFFFFFFF))) & 0xFFFFFFFF
        mx ^= ((s ^ y) + (k[(p & 3) ^ e] ^ z)) & 0xFFFFFFFF
        v[0] = (v[0] - mx) & 0xFFFFFFFF

        s = (s + DELTA) & 0xFFFFFFFF
        q -= 1

    return struct.pack("<%dI" % n_words, *v)

def xor_bytes(data: bytes, x: int) -> bytes:
    return bytes(b ^ x for b in data)

if __name__ == "__main__":
    #hex_ct = "ef32cc75d3ebfaa4dfac21fcfdf3aa4f1e50ea14c0ee9873590495a36fbd6f9deaa7477bbcdcaf28a70f8bff"
    hex_ct = "05d442859c21ac962450db8ebf32cb3d347eb752c39b39dbac8c093e8bcad5e1751c3e50b5e67ecb31125867"

    ct = bytes.fromhex(hex_ct)

    # ✅ pre-xor each byte with 0xE9 before XXTEA decrypt
    ct = xor_bytes(ct, 0xE9)

    pt = xxtea_variant_decrypt(ct)
    print("PT (raw) :", pt)