神奇的开锁师傅

zip 常见攻击汇总

Yolo 这里会对遇到的 zip 攻击做个汇总，对原理会做一个简单的讲解

CRC32 爆破攻击

这有两个重要概念需要清楚（来自 Gemini 老师

CRC32 是什么？

• 全称：Cyclic Redundancy Check，循环冗余校验。
• 用途：它是一种数据完整性校验算法，而不是加密算法。它的主要目的是检查数据在传输或存储过程中是否发生了意外的损坏或改变。
• 原理：它会根据文件的二进制内容，通过一套固定的数学运算，生成一个 32 位的整数值（即 CRC32 校验码）。你可以把它想象成是文件的一个非常简单的“指纹”。如果文件的任何一个比特（bit）发生了改变，那么重新计算出的 CRC32 值有极大的概率会不同。
• 关键特性：计算速度非常快。

ZIP 压缩包的结构

• 一个 ZIP 包里可以包含多个文件。对于每个文件，ZIP 格式都会存储两部分信息：
  • 文件数据（File Data）：这是文件本身的内容，经过压缩和加密。
  • 文件元数据（Metadata/Header）：这是描述文件信息的数据，比如文件名、原始大小、压缩后的大小，以及最重要的——原始文件（未加密前）的 CRC32 校验码。
• 致命缺陷：在使用传统的 ZipCrypto 加密时，文件数据本身是被加密的，但包含 CRC32 值的这部分元数据却是以明文形式存储的，没有被加密。

---

回到这一部分讲解的 crc32 爆破攻击，它有局限性，这种攻击主要针对的是ZipCrypto算法，然后文件的未压缩大小都应该足够小，最好是 6 字节以下

关注的是这一部分，用 bandzip 或其他 zip 解压工具也能看到，基本上都叫做原始大小

解密脚本原理

简单说说这个攻击方法的原理，由于压缩包里面的文件内容很小很小，那么完全可以通过爆破的方式，通过生成所有可能的 3 字节（看未压缩大小）文件，然后和压缩包里的 crc32 值进行匹配，要是成功了，就可以拿它当作已知明文进行明文攻击，获取 flag，到这一步就很轻松了

然后简单说下我的解密脚本逻辑，当未压缩大小在 4 字节之内的话，那就直接明文穷举爆破即可 。然后大小超过 4 字节时，需要使用专门的数学工具进行 crc 反转攻击，原理涉及密码学，zip 加密原理等等（太复杂，没学会，就直接引用 theonlypwner 大佬的工具，然后我再在他的工具基础上，拓展了自行搜集 crc，自行检测密码是否正确的小功能

理论上，单纯使用 crc 反转攻击几乎可以实现所有小字节的爆破攻击，但是我这里依然选择保留 4 字节以下的明文穷举爆破过程，因为那位大佬的工具内置的字符集里面不包含中文字符或别的特殊字符

限制较为严格，我手动尝试添加其他字符的思路是不现实的，综合考虑到如果反转的时候遍历 256 字节，会失去 crc 反转攻击的快速优势，有利有弊吧，最终脚本就这样好了

INFO

其实我在想，如果能优化里面的数学原理的话，就不用怕这个遍历 256 字节了，毕竟我看它的解密过程，完全利用数学特性进行反算，而不是遍历爆破猜测，问题是能力有限，更改字符集的话，就要大幅度的更改当前的解密原理和逻辑，对我来说不现实

解密脚本

脚本 1：

https://github.com/theonlypwner/crc32/blob/main/crc32.py

脚本 2：

#!/usr/bin/env python3

import zipfile
import argparse
import itertools
import subprocess
import re
import zlib
import os
from tqdm import tqdm

def extract_targets(zip_filename: str) -> list:
    """分析 ZIP 文件，提取所有加密文件信息。"""
    targets = []
    print(f"[*] 正在分析压缩包: {zip_filename}")
    try:
        with zipfile.ZipFile(zip_filename, 'r') as zf:
            for info in zf.infolist():
                if info.flag_bits & 0x1 and info.file_size > 0:
                    targets.append({
                        "filename": info.filename, "size": info.file_size, "crc": info.CRC
                    })

        def sort_key(target):
            match = re.search(r'(\d+)', target['filename'])
            if match:
                return (int(match.group(1)), target['filename'])
            return (float('inf'), target['filename'])

        targets.sort(key=sort_key)
        print(f"[+] 发现 {len(targets)} 个加密文件。")
    except (FileNotFoundError, zipfile.BadZipFile) as e:
        print(f"[!] 错误: {e}")
    return targets

def brute_force_many_short_files(targets: list):
    """高效批量爆破 <= 3 位元組的文件。"""
    if not targets: return {}, {}
    print(f"[*] 檢測到 {len(targets)} 个小文件 (<=3 字節)，準備进行高效批量爆破...")
    size_groups = {}
    for t in targets:
        size = t['size']
        if size not in size_groups: size_groups[size] = []
        size_groups[size].append(t)

    crc_to_plaintext = {}
    for length, group_targets in size_groups.items():
        print(f"  [-] 开始对 {len(group_targets)} 个大小为 {length} 字节的文件进行爆破...")
        group_crc_map = {t['crc']: t['filename'] for t in group_targets}
        pbar = tqdm(itertools.product(range(256), repeat=length), total=256**length, desc=f"    -> {length}字节爆破", unit="B", leave=False)
        found_count = 0
        for byte_tuple in pbar:
            plaintext_bytes = bytes(byte_tuple)
            crc_val = zlib.crc32(plaintext_bytes) & 0xFFFFFFFF
            if crc_val in group_crc_map and crc_val not in crc_to_plaintext:
                crc_to_plaintext[crc_val] = plaintext_bytes
                found_count += 1
                pbar.set_postfix_str(f"已找到 {found_count}/{len(group_crc_map)} 个")
            if found_count == len(group_crc_map):
                pbar.update(pbar.total - pbar.n)
                break
        pbar.close()

    crc_map = {}
    for t in targets:
        if t['crc'] not in crc_map: crc_map[t['crc']] = []
        crc_map[t['crc']].append(t['filename'])

    return crc_map, crc_to_plaintext

def reverse_crc_long(targets: list, crc_tool_path: str) -> dict:
    """对 4-7 位元組的文件進行 CRC 反轉。"""
    if not targets: return {}
    print(f"[*] 檢測到 {len(targets)} 個中等大小文件 (4-7 字節)，準備進行 CRC 反轉...")
    fragments_map = {}
    for target in targets:
        filename = target['filename']
        print(f"  [-] 正在调用外部工具为 '{filename}' (大小: {target['size']} B, CRC: {hex(target['crc'])}) 进行反转...")
        command = ["python3", crc_tool_path, "reverse", hex(target['crc'])]
        try:
            proc = subprocess.run(command, capture_output=True, text=True, check=True, encoding='utf-8', errors='ignore')
            fragments = re.findall(r"(?:alternative|bytes):\s+([\w_`~!@#$%^&*()\-+={}\[\]|\\;:'\",./<>?]+)\s+\(OK\)", proc.stdout)
            if fragments:
                unique_fragments = sorted(list(set(fragments)), key=fragments.index)
                fragments_map[filename] = unique_fragments
        except Exception as e:
            print(f"\n[!] 调用 '{crc_tool_path}' 失败: {e}")
    return fragments_map

def known_plaintext_attack(zip_filename: str, cracked_targets: list, cracked_data: dict):
    """自動化執行已知明文攻擊。"""
    print("\n--- 可能性#2: 将恢复内容作为已知明文进行攻击 ---")

    total_plaintext_len = sum(t['size'] for t in cracked_targets)
    if total_plaintext_len < 12:
        print(f"[!] 破解出的小文件总长度 ({total_plaintext_len} 字節) 不足12位元組，无法进行已知明文攻击。"); return
    attack_targets, current_len = [], 0
    for t in cracked_targets:
        attack_targets.append(t); current_len += t['size']
        if current_len >= 12: break

    plaintext_bytes = b"".join(cracked_data[t['crc']] for t in attack_targets)
    plaintext_file, ciphertext_zip = "known_plaintext.tmp", "ciphertext_archive.tmp.zip"

    try:
        with open(plaintext_file, "wb") as f: f.write(plaintext_bytes)
        print(f"[*] 已生成临时明文文件 '{plaintext_file}' ({len(plaintext_bytes)} 字節)。")
        with open(zip_filename, 'rb') as original_zip_f, \
             zipfile.ZipFile(ciphertext_zip, 'w') as temp_zip:
            with zipfile.ZipFile(zip_filename, 'r') as original_zip_obj:
                for target in attack_targets:
                    info = original_zip_obj.getinfo(target['filename'])
                    header = info.FileHeader()
                    data_offset = info.header_offset + len(header)
                    original_zip_f.seek(data_offset)
                    encrypted_data = original_zip_f.read(info.compress_size)
                    temp_zip.writestr(info, encrypted_data)
        print(f"[*] 已生成临时密文压缩包 '{ciphertext_zip}'。")
        print("\n[*] 正在调用 bkcrack 恢复加密密钥..."); command_keys = ["bkcrack", "-C", ciphertext_zip, "-p", plaintext_file]
        proc_keys = subprocess.run(command_keys, capture_output=True, text=True)
        if proc_keys.returncode != 0:
            print("[!] bkcrack 密钥恢复失败。"); print(proc_keys.stdout); print(proc_keys.stderr); return
        keys_match = re.search(r"Keys: ([0-9a-fA-F]+ [0-9a-fA-F]+ [0-9a-fA-F]+)", proc_keys.stdout)
        if not keys_match:
            print("[!] 未能从 bkcrack 的输出中解析出密钥。"); print(proc_keys.stdout); return
        keys = keys_match.group(1)
        print(f"    [+] 成功恢复密钥: {keys}")
        flag_target_info = max(zipfile.ZipFile(zip_filename, 'r').infolist(), key=lambda i: i.file_size)
        flag_filename, decrypted_output_filename = flag_target_info.filename, "flag_decrypted.txt"
        print(f"\n[*] 正在使用密钥解密目标文件 '{flag_filename}'...")
        command_decrypt = ["bkcrack", "-C", zip_filename, "-k", keys, "-d", flag_filename, "-o", decrypted_output_filename]
        proc_decrypt = subprocess.run(command_decrypt, capture_output=True, text=True)
        if proc_decrypt.returncode != 0:
            print(f"[!] 使用密钥解密 '{flag_filename}' 失败。"); print(proc_decrypt.stderr); return
        print("\n" + "="*50); print(f"🎉 [+] 攻擊成功！"); print(f"    >>> 已將 '{flag_filename}' 解密並保存為 '{decrypted_output_filename}' <<<"); print("="*50)
    finally:
        print("\n[*] 清理临时文件中...");
        if os.path.exists(plaintext_file): os.remove(plaintext_file)
        if os.path.exists(ciphertext_zip): os.remove(ciphertext_zip)

def test_password(zip_filename: str, password_bytes: bytes, test_file: str) -> bool:
    try:
        with zipfile.ZipFile(zip_filename, 'r') as zf:
            zf.read(test_file, pwd=password_bytes)
        return True
    except Exception:
        return False

def main():
    parser = argparse.ArgumentParser(description="终极完美版 CRC 攻击脚本 V12。")
    parser.add_argument("zip_file", help="需要破解的 ZIP 文件路径。")
    parser.add_argument("--tool", type=str, default="crc32.py", help="可用的 crc32.py 工具路径。")
    args = parser.parse_args()

    all_targets = extract_targets(args.zip_file)
    if not all_targets: return

    short_targets = [t for t in all_targets if t['size'] <= 3]
    medium_targets = [t for t in all_targets if 4 <= t['size'] <= 7]
    large_targets = [t for t in all_targets if t['size'] >= 8]

    print(f"\n[*] 文件分析完成，分组如下:")
    print(f"  - {len(short_targets)} 个小文件 (<=3 字节) -> 将使用二进制爆破")
    print(f"  - {len(medium_targets)} 个中等文件 (4-7 字节) -> 将使用 CRC 反转")
    print(f"  - {len(large_targets)} 个大文件 (>=8 字节) -> 将被忽略")
    print("-" * 50)

    final_results = {}
    if short_targets:
        crc_map, crc_to_plaintext = brute_force_many_short_files(short_targets)
        for crc, plaintext in crc_to_plaintext.items():
            for fname in crc_map.get(crc, []):
                final_results[fname] = [plaintext]

    if medium_targets:
        fragments_map = reverse_crc_long(medium_targets, args.tool)
        for fname, frags in fragments_map.items():
            final_results[fname] = frags

    if not final_results:
        print("\n[!] 未能破解或恢复任何文件内容。")
        return

    print("\n" + "="*50); print("🎉 [+] 初步破解/恢复完成！结果如下："); print("="*50)
    ordered_cracked_filenames = [t['filename'] for t in all_targets if t['filename'] in final_results]

    decoded_parts_for_summary = []
    for filename in ordered_cracked_filenames:
        content_list = final_results[filename]

        display_parts = []
        is_binary_in_list = False
        for content in content_list:
            if isinstance(content, bytes):
                is_binary_in_list = True
                try:
                    decoded_str = content.decode('utf-8')
                    if decoded_str.isprintable():
                        display_parts.append(f"'{decoded_str}'")
                    else:
                        display_parts.append(str(content))
                except UnicodeDecodeError:
                    display_parts.append(str(content))
            else:
                display_parts.append(f"'{content}'")


        decoded_parts_for_summary.append(display_parts[0].strip("'"))

        print(f"  -> 文件 '{filename}': [{', '.join(display_parts)}]")

    print("\n[*] 以上所有结果的**首个**可能性拼接后的内容为:")
    full_decoded_text = "".join(decoded_parts_for_summary)
    print(f"    解码后文本: {full_decoded_text}")

    try:
        choice = input("\n[?] 是否要继续尝试自动攻击？(y/n): ")
    except KeyboardInterrupt:
        print("\n操作已取消。"); return
    if choice.lower() != 'y':
        print("[*] 操作结束。"); return

    if medium_targets:
        print("\n--- 尝试将 CRC 反转结果组合成密码 ---")
        password_fragment_lists = [final_results[t['filename']] for t in medium_targets if t['filename'] in final_results]
        if password_fragment_lists:
            test_file = max(all_targets, key=lambda t: t['size'])['filename']
            print(f"[*] 自动选择最大文件 '{test_file}' 用于密码验证。")
            total_passwords = 1
            for frags in password_fragment_lists: total_passwords *= len(frags)
            pbar = tqdm(itertools.product(*password_fragment_lists), total=total_passwords, desc="  -> 尝试密码")
            for combo in pbar:
                password_bytes = "".join(combo).encode('utf-8')
                pbar.set_postfix_str(f"正在尝试: {password_bytes.decode(errors='ignore')[:30]}...")
                if test_password(args.zip_file, password_bytes, test_file):
                    pbar.close()
                    print("\n" + "="*50); print(f"🎉 [+] 最终密码验证成功！"); print(f"  >>>  {password_bytes.decode()}  <<<"); print("="*50)
                    return
            print("\n[!] 未能自动验证出正确的密码组合。")

    if short_targets:
        cracked_data_map = {t['crc']: final_results[t['filename']][0] for t in short_targets if t['filename'] in final_results}
        cracked_short_targets = [t for t in short_targets if t['filename'] in final_results and isinstance(final_results[t['filename']][0], bytes)]
        if cracked_short_targets:
             known_plaintext_attack(args.zip_file, cracked_short_targets, cracked_data_map)

if __name__ == "__main__":
    main()

例题一

攻防世界-crc

首先通过 bkcrack 可以直观的看到压缩包的结构以及压缩方式等等，通过特征，我们能判断使用 crc32 爆破攻击

bkcrack -L ad71bf43131c4b3fa27066a3b408f843.zip
bkcrack 1.7.1 - 2024-12-21
Archive: ad71bf43131c4b3fa27066a3b408f843.zip
Index Encryption Compression CRC32    Uncompressed  Packed size Name
----- ---------- ----------- -------- ------------ ------------ ----------------
    0 ZipCrypto  Store       cc86365b            6           18 1.txt
    1 ZipCrypto  Store       bcee7ed5            6           18 2.txt
    2 ZipCrypto  Store       ccca7e74            6           18 3.txt
    3 ZipCrypto  Deflate     9ebfae5d        15360         1962 convert.txt

因为是 6 字节，所以使用 crc 反转攻击效率更高，而且我的脚本会自行检测字节大小来选择爆破模式，直接用脚本+压缩包即可

那个 convert.txt 是串二进制，解密出来是个二维码，扫描得到 flag

flag{owid0-o91hf-9iahg}

例题二

ISCTF2023-ezcrc

这道题老坑了呢，那些小字节里的内容都是中文，所以说常用的 crc 爆破工具根本做不了，反转也用不了，好在，原始字节就 3 个，直接遍历爆破即可（为了加速爆破，选择一次性批量爆破，这样做比一个一个文件单独爆破要快得多得多

bkcrack -L ezcrc.zip
bkcrack 1.7.1 - 2024-12-21
Archive: ezcrc.zip
Index Encryption Compression CRC32    Uncompressed  Packed size Name
----- ---------- ----------- -------- ------------ ------------ ----------------
    0 ZipCrypto  Store       d2b184ff            3           15 0.txt
    1 ZipCrypto  Store       b462df74            3           15 1.txt
    2 ZipCrypto  Store       b462df74            3           15 10.txt
    3 ZipCrypto  Store       fd2a257b            3           15 100.txt
    4 ZipCrypto  Store       d2b184ff            3           15 101.txt
   ......
   yolo@Yolo:~/Desktop/timu/crcbaopo$ python finalfinal.py ezcrc.zip
[*] 正在分析压缩包: ezcrc.zip
[+] 发现 227 个加密文件。

[*] 检测到批量小文件场景，进入“高效内容恢复”模式。
[*] 正在准备高效批量爆破...
[*] 开始对 30 个独特的 CRC 值进行 3 字节爆破...
    -> 爆破进度:  91%|██████████████████████████████▏  | 15317381/16777216 [00:04<00:00, 3514721.50B/s, 已找到 30/30 个]

[*] 爆破完成！总共 30 个独特CRC，成功破解 30 个。

[*] 正在拼接最终结果...

==================================================
🎉 [+] 内容恢复完成！
==================================================
原始字节流 (这才是真实数据):
b'\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xb9\x8c\xe5\xa3\xb9\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xb5\x84\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\x96\x94\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x97\xa5\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xbd\x9b\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xb5\x84\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xbd\x9b\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\xb7\xab\xe5\x9f\xba\xe5\xbe\x97\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\x96\x94\xe7\x8e\xbb\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xb9\x8c\xe9\x9b\xb6\xe8\xb5\x84\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\xb7\xab\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xbf\x82\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x97\xa5\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xbf\x82\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xae\xb7\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xb9\x8c\xe5\xa3\xb9\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\xb8\x8c\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x97\xa5\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\xb8\x8c\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x97\xa5\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\x96\x94\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xbf\x82\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\x93\xa5\xe5\xbe\x97\xe9\x99\x86\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe7\x89\xb9\xe6\x91\xb8\xe7\xa7\x91\xe5\xb7\xab\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x91\xb8\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xbd\x9b\xe5\x8b\x92\xe7\x89\xb9\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe7\x89\xb9\xe6\x91\xb8\xe5\xb8\x8c\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x91\xb8\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xbf\x82\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\x93\xa5\xe9\x9b\x8c\xe5\xb8\x8c\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe7\x89\xb9\xe9\x9b\xb6\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x97\xa5\xe5\x9f\xba\xe5\xbe\x97\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xbd\x9b\xe5\x9d\xa1\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe5\x96\x9d\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xb9\x8c\xe6\x91\xb8\xe5\x8b\x92\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xae\xb7\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x91\xb8\xe7\xa7\x91\xe5\x8b\x92\xe5\x8f\x81\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe7\x89\xb9\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xbf\x82\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x97\xa5\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x97\xa5\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x91\xb8\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xb9\x8c\xe5\xa3\xb9\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe9\xb9\x85\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe6\x80\x9d\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe7\x89\xb9\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe8\xae\xb7\xe6\x91\xb8\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe4\xb9\x8c\xe5\xa4\xa7\xe5\x86\x99\xe7\x9a\x84\xe7\x89\xb9\xe9\x9b\xb6\xe7\x8e\x96'

尝试用 UTF-8 解码后的文本 (可能乱码):
大写的乌壹大写的资大写的喔大写的日大写的佛大写的资大写的佛大写的巫基得大写的喔玻大写的乌零资大写的巫大写的迂大写的日大写的迂大写的讷大写的乌壹大写的希大写的日大写的希大写的日大写的喔大写的迂大写的哥得陆大写的特摸科巫大写的摸大写的佛勒特大写的特摸希大写的摸大写的迂大写的哥雌希大写的特零大写的日基得大写的佛坡大写的喝大写的乌摸勒大写的讷大写的摸科勒叁大写的特大写的迂大写的日大写的日大写的摸大写的乌壹大写的鹅大写的思大写的特大写的讷摸大写的乌大写的特零玖

[*] 原始字节流已保存到 'recovered_content.dat' 文件中，方便进一步分析。

这个就是压缩包所有小字节的内容：
大写的乌壹大写的资大写的喔大写的日大写的佛大写的资大写的佛大写的巫基得大写的喔玻大写的乌零资大写的巫大写的迂大写的日大写的迂大写的讷大写的乌壹大写的希大写的日大写的希大写的日大写的喔大写的迂大写的哥得陆大写的特摸科巫大写的摸大写的佛勒特大写的特摸希大写的摸大写的迂大写的哥雌希大写的特零大写的日基得大写的佛坡大写的喝大写的乌摸勒大写的讷大写的摸科勒叁大写的特大写的迂大写的日大写的日大写的摸大写的乌壹大写的鹅大写的思大写的特大写的讷摸大写的乌大写的特零玖

哈哈，读完我就笑了，这里的东西全是拼音表还有数字呢

基本上是参考这个表，写个替换反转脚本

# -*- coding: UTF-8 -*-

mapping = {
    # 大写字母
    '大写的啊': 'A',
    '大写的玻': 'B',
    '大写的雌': 'C',
    '大写的得': 'D',
    '大写的鹅': 'E',
    '大写的佛': 'F',
    '大写的哥': 'G',
    '大写的喝': 'H',
    '大写的衣': 'I',
    '大写的基': 'J',
    '大写的科': 'K',
    '大写的勒': 'L',
    '大写的摸': 'M',
    '大写的讷': 'N',
    '大写的喔': 'O',
    '大写的坡': 'P',
    '大写的欺': 'Q',
    '大写的日': 'R',
    '大写的思': 'S',
    '大写的特': 'T',
    '大写的乌': 'U',
    '大写的迂': 'V',
    '大写的巫': 'W',
    '大写的希': 'X',
    '大写的资': 'Z',  # 注意：原文中 Y 和 Z 的中文描述重复了“衣”和“资”，这里修正
    # 小写字母
    '啊': 'a',
    '玻': 'b',
    '雌': 'c',
    '得': 'd',
    '鹅': 'e',
    '佛': 'f',
    '哥': 'g',
    '喝': 'h',
    '衣': 'i',
    '基': 'j',
    '科': 'k',
    '勒': 'l',
    '摸': 'm',
    '讷': 'n',
    '喔': 'o',
    '坡': 'p',
    '欺': 'q',
    '日': 'r',
    '思': 's',
    '特': 't',
    '乌': 'u',
    '迂': 'v',
    '巫': 'w',
    '希': 'x',
    '衣': 'y',  # 注意：'衣' 出现两次，这里优先小写 y
    '资': 'z',
    # 数字
    '零': '0',
    '壹': '1',
    '贰': '2',
    '叁': '3',
    '肆': '4',
    '伍': '5',
    '陆': '6',
    '柒': '7',
    '捌': '8',
    '玖': '9',
    '歪': 'y',
}

def chinese_to_char(text):
    result = text
    # 按照映射表逐个替换
    for chinese, char in mapping.items():
        result = result.replace(chinese, char)
    return result

test = "大写的乌壹大写的资大写的喔大写的日大写的佛大写的资大写的佛大写的巫基得大写的喔玻大写的乌零资大写的巫大写的迂大写的日大写的迂大写的讷大写的乌壹大写的希大写的日大写的希大写的日大写的喔大写的迂大写的哥得陆大写的特摸科巫大写的摸大写的佛勒特大写的特摸希大写的摸大写的迂大写的哥雌希大写的特零大写的日基得大写的佛坡大写的喝大写的乌摸勒大写的讷大写的摸科勒叁大写的特大写的迂大写的日大写的日大写的摸大写的乌壹大写的鹅大写的思大写的特大写的讷摸大写的乌大写的特零玖"

output = chinese_to_char(test)
print("映射结果:", output)

然后将结果进行两次 base64 解码，拿到 flag