CTF-逆向篇

#

# 根据 IDA 逆向分析结果编写的 RC4 解密脚本

#

# ========================== 用户配置区 ==========================

# ❗️ 在这里填入加密时使用的密钥

YOUR_SECRET_KEY = "[Warnning]Access_Unauthorized"

# ❗️ 填入加密后的文件名 (即 enflag.txt 的路径)

ENCRYPTED_FILE_PATH = "enflag.txt"

# ❗️ 填入保存解密后文件的名字

DECRYPTED_FILE_PATH = "flag_decrypted.txt"

# =============================================================

class RC4:

    def __init__(self, key: str):

        """

        使用密钥初始化RC4状态，完成密钥调度算法(KSA)。

        这个构造函数完整复刻了 sub_401780, sub_401800, 和 sub_4018E0 的功能。

        """

        key_bytes = key.encode('ascii')  # 将字符串密钥转为字节

        key_length = len(key_bytes)

        # 对应 sub_401780: 初始化 S-box, S [i] = i

        self.S = list(range(256))

        # 对应 sub_401800: 根据密钥初始化 T-vector

        T = [key_bytes[i % key_length] for i in range(256)]

        # 对应 sub_4018E0: 使用 T-vector 对 S-box 进行初始置换

        j = 0

        for i in range(256):

            j = (j + self.S[i] + T[i]) % 256

            # 交换 S [i] 和 S [j]

            self.S[i], self.S[j] = self.S[j], self.S[i]

        print("✅ RC4 状态初始化完成 (KSA complete).")

    def crypt(self, data: bytes) -> bytes:

        """

        对数据进行加密或解密。

        这个方法完整复刻了 sub_4015E0 (PRGA) 的功能。

        """

        i = 0

        j = 0

        output = bytearray()

        for byte in data:

            i = (i + 1) % 256

            j = (j + self.S[i]) % 256

            # 交换 S [i] 和 S [j]

            self.S[i], self.S[j] = self.S[j], self.S[i]

            # 计算 t 并生成密钥流字节 k

            t = (self.S[i] + self.S[j]) % 256

            keystream_byte = self.S[t]

            # 将数据字节与密钥流字节进行 XOR

            output.append(byte ^ keystream_byte)

        return bytes(output)

# --- 主执行逻辑 ---

if __name__ == "__main__":

    print("--- RC4解密程序启动 ---")

    # 检查密钥是否已填写

    try:

        # 1. 读取加密后的文件内容

        print(f"📄 正在读取加密文件: {ENCRYPTED_FILE_PATH}")

        with open(ENCRYPTED_FILE_PATH, 'rb') as f:

            encrypted_data = f.read()

        print(f"   读取了 {len(encrypted_data)} 字节数据。")

        # 2. 使用密钥初始化 RC4 加密器

        print(f"🔑 使用密钥 '{YOUR_SECRET_KEY}' 初始化RC4...")

        cipher = RC4(YOUR_SECRET_KEY)

        # 3. 执行解密 (与加密过程完全相同)

        print("⚙️ 正在执行解密操作...")

        decrypted_data = cipher.crypt(encrypted_data)

        print("   解密完成。")

        # 4. 将解密后的数据写入新文件

        print(f"💾 正在将解密结果写入文件: {DECRYPTED_FILE_PATH}")

        with open(DECRYPTED_FILE_PATH, 'wb') as f:

            f.write(decrypted_data)

        print("\n" + "=" * 50)

        print(f"🎉 解密成功！结果已保存至 {DECRYPTED_FILE_PATH}")

        print("=" * 50)

    except FileNotFoundError:

        print(f"❌ 错误: 找不到文件 '{ENCRYPTED_FILE_PATH}'。请检查文件名和路径是否正确。")

    except Exception as e:

        print(f"❌ 发生未知错误: {e}")

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

def calculate_hex_key():

    """

    根据已知的校验和算法和 "%x" 格式，直接计算出最终的key。

    """

    # 1. 初始化常量

    s_fixed_values = [

        0x50,  # s[0] = x

        0xfae3,  # s[1] = c

        0xd7d3f7b,  # s[2] = v

        0xa43499f6,  # s[3] = n

        0x10 + 5 * 0x1000,  # s[4] = m + b * 0x1000

        0xef9  # s[5] = h

    ]

    # 2. 计算已知数值的总和

    fixed_sum = sum(s_fixed_values)

    # 3. 模拟 C 代码中的校验和折叠算法

    def checksum_fold(value):

        while value > 0xffff:

            value = (value & 0xffff) + (value >> 16)

        return value

    # 4. 计算部分校验和

    partial_checksum = checksum_fold(fixed_sum)

    # 5. 根据目标 0xffff 计算出 j 的值

    target = 0xffff

    j = target - partial_checksum

    # 6. 构造最终的 key

    # 格式为 "% x"，所以使用 j 的十六进制字符串表示

    # 末尾附加任意 6 个字符以满足程序的长度要求

    final_key = f"{j:x}" + "A" * 6

    print("=" * 40)

    print("已确认 sscanf 格式为 '%x'.")

    print(f"计算出的 j 的值: 0x{j:x}")

    print(f"因此, 正确的 Key 是: {final_key}")

    print("=" * 40)

if __name__ == "__main__":

    calculate_hex_key()

import zipfile

import os

import sys

import datetime

import argparse

def analyze_jar(filepath):

    """

    Analyzes the structure of a JAR/ZIP file, showing offsets and appended data.

    """

    if not os.path.exists(filepath):

        print(f"错误: 文件不存在 '{filepath}'")

        return

    print(f"--- 开始分析: {os.path.basename(filepath)} ---")

    print(f"文件总大小: {os.path.getsize(filepath):,} 字节")

    print("-" * 40)

    try:

        with zipfile.ZipFile(filepath, 'r') as zf:

            print("[+] 文件列表和内部结构:\n")

            infolist = zf.infolist()

            if not infolist:

                print("  -> 此JAR包为空或无法识别内部文件。")

            for info in infolist:

                # ZipInfo 对象包含了丰富的元数据

                header_offset = info.header_offset

                filename = info.filename

                # 计算压缩数据的真实起始偏移量

                # 公式：数据偏移量 = 文件头偏移量 + 30 (固定头大小) + 文件名长度 + 额外字段长度

                data_offset = header_offset + 30 + len(filename.encode('utf-8')) + len(info.extra)

                print(f"  文件名: {filename}")

                print(f"    ├─ 修改时间: {datetime.datetime(*info.date_time)}")

                print(f"    ├─ 文件头偏移量 (Header Offset): {header_offset:<10} (0x{header_offset:08X})")

                print(f"    ├─ 数据偏移量 (Data Offset):   {data_offset:<10} (0x{data_offset:08X})")

                print(f"    ├─ 压缩后大小: {info.compress_size:,} 字节")

                print(f"    ├─ 原始大小:   {info.file_size:,} 字节")

                print(f"    └─ CRC校验码:  0x{info.CRC:08X}\n")

    except zipfile.BadZipFile as e:

        print(f"[!] 严重错误: {e}")

        print("    -> 文件不是一个有效的JAR/ZIP文件，或者已经严重损坏。")

    except Exception as e:

        print(f"[!] 发生未知错误: {e}")

    # --- 手动检查文件末尾的附加数据 ---

    print("[+] 附加数据检查:")

    with open(filepath, 'rb') as f:

        # ZIP 文件的结尾记录（EOCD）标志是 PK\x05\x06

        eocd_signature = b'\x50\x4B\x05\x06'

        # 从文件末尾开始搜索，效率更高

        f.seek(0, os.SEEK_END)

        filesize = f.tell()

        # 我们只在文件末尾一小块区域内搜索，以防万一

        read_buffer = max(0, filesize - 65536)

        f.seek(read_buffer)

        data = f.read()

        eocd_pos_in_data = data.rfind(eocd_signature)

        if eocd_pos_in_data == -1:

            print("  -> 未找到标准的ZIP文件结尾记录 (EOCD)。")

            print("     这证实了 'zip END header not found' 错误。文件可能不完整。")

        else:

            eocd_abs_pos = read_buffer + eocd_pos_in_data

            # EOCD 记录中，注释长度字段在偏移量 20 处，占 2 字节

            comment_len_bytes = data[eocd_pos_in_data + 20: eocd_pos_in_data + 22]

            comment_len = int.from_bytes(comment_len_bytes, 'little')

            # ZIP 文件的理论结束位置

            expected_end = eocd_abs_pos + 22 + comment_len

            print(f"  -> 找到文件结尾记录 (EOCD) 在偏移量: {eocd_abs_pos}")

            print(f"  -> ZIP结构理论结束位置: {expected_end}")

            if filesize > expected_end:

                appended_size = filesize - expected_end

                print(f"  -> [!] 警告: 文件末尾发现 {appended_size:,} 字节的附加数据！")

            else:

                print("  -> 正常: 未发现附加数据。")

    print("-" * 40)

    print("--- 分析结束 ---")

if __name__ == '__main__':

    parser = argparse.ArgumentParser(description="分析一个JAR/ZIP文件的内部结构、偏移量和附加数据。")

    parser.add_argument("jarfile", help="需要分析的JAR文件路径")

    args = parser.parse_args()

    analyze_jar(args.jarfile)

import zipfile

import argparse

import os

def separate_jar_components_v2(source_jar_path):

    OBFUSCATED_SOURCE_NAME = 'EzJar.class/EzJar.java'

    OBFUSCATED_BYTECODE_NAME = 'EzJar.class/'

    OUTPUT_SOURCE_JAR = 'source_code.jar'

    OUTPUT_BYTECODE_JAR = 'compiled_bytecode.jar'

    CLEAN_SOURCE_NAME = 'EzJar.java'

    CLEAN_BYTECODE_NAME = 'EzJar.class'

    # 标准清单文件的内容

    # MANIFEST_CONTENT = "Manifest-Version: 1.0\n\n"

    MANIFEST_CONTENT = "Manifest-Version: 1.0\nMain-Class: EzJar\n\n"

    MANIFEST_PATH = "META-INF/MANIFEST.MF"

    if not os.path.exists(source_jar_path):

        print(f"错误: 源文件不存在 '{source_jar_path}'")

        return

    source_data = None

    bytecode_data = None

    print(f"--- 正在分析 '{source_jar_path}' ---")

    try:

        with zipfile.ZipFile(source_jar_path, 'r') as zf:

            for info in zf.infolist():

                if info.filename == OBFUSCATED_SOURCE_NAME:

                    source_data = zf.read(info)

                elif info.filename == OBFUSCATED_BYTECODE_NAME:

                    bytecode_data = zf.read(info)

        # 创建源代码 JAR

        if source_data:

            print(f"正在创建标准源代码包 -> '{OUTPUT_SOURCE_JAR}'...")

            with zipfile.ZipFile(OUTPUT_SOURCE_JAR, 'w', compression=zipfile.ZIP_DEFLATED) as zf_source:

                # 添加清单文件

                zf_source.writestr(MANIFEST_PATH, MANIFEST_CONTENT)

                # 添加源代码文件

                zf_source.writestr(CLEAN_SOURCE_NAME, source_data)

            print(f" -> 成功创建 '{OUTPUT_SOURCE_JAR}'")

        # 创建字节码 JAR

        if bytecode_data:

            print(f"正在创建标准字节码包 -> '{OUTPUT_BYTECODE_JAR}'...")

            with zipfile.ZipFile(OUTPUT_BYTECODE_JAR, 'w', compression=zipfile.ZIP_DEFLATED) as zf_bytecode:

                # 添加清单文件

                zf_bytecode.writestr(MANIFEST_PATH, MANIFEST_CONTENT)

                # 添加字节码文件

                zf_bytecode.writestr(CLEAN_BYTECODE_NAME, bytecode_data)

            print(f" -> 成功创建 '{OUTPUT_BYTECODE_JAR}'")

        print("\n--- 分离完成 ---")

    except Exception as e:

        print(f"[!] 处理过程中发生错误: {e}")

if __name__ == '__main__':

    parser = argparse.ArgumentParser(description="将一个混淆的JAR文件分离成两个包含标准清单的、干净的JAR文件。")

    parser.add_argument("source_jar", help="原始的、被混淆的JAR文件路径。")

    args = parser.parse_args()

    separate_jar_components_v2(args.source_jar)

import base64

import hashlib

from Crypto.Cipher import DES, Blowfish

from Crypto.Util.Padding import unpad

# 全局变量，用于存储 Java 代码中的 l 和 I 数组

l = [0] * 18

I = [""] * 17

def lII():

    """复刻Java的lII()方法，计算出l[]数组的值"""

    global l

    l[0] = (156 ^ 136) & ~(127 ^ 107)

    l[1] = 1

    l[2] = 3

    l[3] = 2

    l[4] = 185 ^ 197 ^ 32 ^ 88

    l[5] = 1 ^ 28 ^ 24

    l[6] = 16 ^ 22

    l[7] = 69 ^ 77 ^ 70 ^ 73

    l[8] = (106 + 107 - 66 + 32) ^ (33 + 90 - 98 + 162)

    l[9] = (154 + 21 - 48 + 38) ^ (78 + 146 - 163 + 111)

    l[10] = 29 ^ 23

    l[11] = 64 ^ 75

    l[12] = 105 ^ 101

    l[13] = 2 ^ 106 ^ 101

    l[14] = 72 ^ 70

    l[15] = 144 ^ 159

    l[16] = 160 ^ 176

    l[17] = 177 ^ 160

def decrypt_l(b64_str, key_str):

    """复刻Java的l()方法 (XOR解密)"""

    decoded_bytes = base64.b64decode(b64_str)

    key_bytes = key_str.encode('utf-8')

    result = bytearray()

    for i in range(len(decoded_bytes)):

        result.append(decoded_bytes[i] ^ key_bytes[i % len(key_bytes)])

    return result.decode('utf-8')

def decrypt_lI(b64_str, key_str):

    """复刻Java的lI()方法 (Blowfish解密)"""

    key = hashlib.md5(key_str.encode('utf-8')).digest()

    cipher = Blowfish.new(key, Blowfish.MODE_ECB)

    decoded_bytes = base64.b64decode(b64_str)

    return unpad(cipher.decrypt(decoded_bytes), Blowfish.block_size).decode('utf-8')

def decrypt_I(b64_str, key_str):

    """复刻Java的I()方法 (DES解密)"""

    # Java 的 Arrays.copyOf (..., 8) 相当于取前 8 个字节

    key = hashlib.md5(key_str.encode('utf-8')).digest()[:8]

    cipher = DES.new(key, DES.MODE_ECB)

    decoded_bytes = base64.b64decode(b64_str)

    return unpad(cipher.decrypt(decoded_bytes), DES.block_size).decode('utf-8')

def ll():

    """复刻Java的ll()方法，解密并填充I[]数组"""

    global I, l

    I[l[0]] = decrypt_I("AQiA0bYffm9HvMlm7RnEMX/tEQAUj4Xb", "FrlAZ")

    I[l[1]] = decrypt_I("hXzZyx8IUHw=", "Esxsh")

    I[l[3]] = decrypt_l("ID8PFlEKM1kKHhIkWRUdBjFD", "gVysq")

    I[l[2]] = decrypt_I("50fO6ARqllg=", "VZbFF")

    I[l[4]] = decrypt_lI("mvXqH+/XIESPZaSG3ZbZlA==", "TuZSw")

    I[l[5]] = decrypt_l("JQ0R", "aHBFu")

    I[l[6]] = decrypt_I(

        "dMKiRQ19iTevvzL7NtVg5+ye5BywL2QaxtVANFLuC5B2/KuC+/5L6BwtCB7zpWK1XBTQr0VWC3Vt/uYEl2xmjskE0dDrCk2C", "dPxYA")

    I[l[7]] = decrypt_lI("B/MVYKSzgq8=", "phiUP")

    I[l[8]] = decrypt_I("ZtBOhuHeK3Y=", "MfnkQ")

    I[l[9]] = decrypt_lI("aPhz+GjGynRlU3Alo00QeQ==", "wWtUj")

    I[l[10]] = decrypt_l("BRQFNiRyBwQrNDcUSw==", "RfjXC")

    I[l[11]] = decrypt_I("pT10j0lChvyrNwYRFdqBzxqFp1ruTgo9", "hGcuT")

    I[l[12]] = decrypt_lI(

        "UhBbCDk5yqaWl1uHJyS/OGmtcfVyvOOsk78/1f0MU8U3UfAf1Xf0FWNbpcKes/0HRz9SU/icRJHswW2xWjHrcFzhpsvwzqUl", "eeMoV")

    I[l[13]] = decrypt_I("s11BihYBzRBpcX9EF43utw==", "RjiXK")

    I[l[14]] = decrypt_I("wk5jH1cyKoA=", "frsxP")

    I[l[15]] = decrypt_I("Nfa0rxB8IRArMq2F4iLlLg==", "ulQWJ")

    I[l[16]] = decrypt_lI("wLcWNd0Xsbw=", "JgPGn")

def final_crack():

    """执行最终的核心破解逻辑"""

    print("[+] 正在复刻Java内部的解密过程...")

    # 步骤一：初始化常量数组 l 和 I

    lII()

    ll()

    print("[+] 已成功解密并重建所有隐藏字符串。")

    # 步骤二：从重建的数组中获取关键信息

    # main 方法中的密钥是 I [l [4]]，l [4] 的值是 4

    main_logic_key_str = I[l[4]]

    # main 方法中的目标密文是 I [l [6]]，l [6] 的值是 6

    main_logic_ciphertext_b64 = I[l[6]]

    print(f"    -> 破解出的DES密钥: {main_logic_key_str}")

    print(f"    -> 破解出的目标密文: {main_logic_ciphertext_b64[:20]}...")

    # 步骤三：执行最终的 DES 解密

    print("[+] 正在执行最终解密...")

    key_bytes = main_logic_key_str.encode('utf-8')

    ciphertext_bytes = base64.b64decode(main_logic_ciphertext_b64)

    cipher = DES.new(key_bytes, DES.MODE_ECB)

    decrypted_padded_bytes = cipher.decrypt(ciphertext_bytes)

    # 移除填充

    flag = unpad(decrypted_padded_bytes, DES.block_size).decode('utf-8')

    print("-" * 50)

    print(f"[*] 最终Flag: {flag}")

    print("-" * 50)

if __name__ == '__main__':

    final_crack()