[ misc 知识点 ] bkcrack 已知明文攻击

特征

🏷️ 例题：
| 20251206Mini VN D u know Pyc？（pyc头部构建+明文攻击）
| 20251201ISCTF 小蓝鲨的千层嵌套（ZIP嵌套+明文攻击）
| 4.压缩包分析 GHCTF-mybrave / HDCTF-ExtremeMisc
| 20260130furryCTF 学习资料（docx文件头构建）
| 20260202SHCTF Open my puff / 资源平权（exe文件头）

ZIP 老式 ZipCrypto 加密能用已知明文反推密钥；条件：加密算法是 ZipCrypto（WinRAR/7-Zip 默认 AES 不行）、压缩方式是 Store 或 Deflate、已知 ≥12 字节明文且 8 字节连续、明文偏移确定。

坑：同一明文，7-zip / WinRAR / Windows 自带压出来的压缩流 A≠B≠C，攻击前先判断压缩工具，用对应工具压缩已知明文再打。

前提条件

条件	说明
✅ 1. 加密方式为 ZipCrypto	WinRAR、7-Zip 默认使用 AES-256，无法攻击； 需确认是老式 PKZIP 加密
✅ 2. 压缩方式为Store(存储)/Deflate(压缩)	加密算法为：ZipCrypto 如果仅有部分明文，则压缩算法必须为**Store** 如果有至少一个完整明文则压缩算法可为**Deflate**
✅ 3. 已知至少 12 字节明文，其中至少 8 字节连续	明文需对应到加密前文件的确切偏移位置

攻击原理

ZipCrypto 用 32位×3 内部状态（key0,key1,key2）生成伪随机 keystream 与明文异或。1994 年 Eli Biham / Paul Kocher：知道 12~13 字节明文+密文对就能差分恢复 keys（a1b2c3d4 e5f6g7h8 i9j0k1l2）。拿到 keys 能解密任意文件、改密码、爆破短密码。

bkcrack

GitHub: https://github.com/kimci86/bkcrack

however **-p**提供主体连续明文 **-x**补充碎片明文 组合使用达到≥8+4字节

参数	含义
-C encrypted.zip	目标加密ZIP文件
-c target_file.???	要攻击的内部文件名（必须存在于 -C中）
-p plain.bin	明文文件（内容 = 原始未加密数据）
-o N	-p中的明文在原始文件中的起始偏移（字节）
-x offset hex_bytes	补充非连续明文，offset是相对于原始文件的偏移，hex_bytes是十六进制字符串
-k key0 key1 key2	已知密钥时，用于解密
-d output.???	解密输出文件

怎么用

假设flag.zip已知内部有且只有flag.png

step1:把bkcrack.exe和flag.zip放在同一级文件夹flag下 运行bkcrack

**cd C:\Users\13964\Desktop\flag**

**bkcrack.exe -C flag.zip flag.png -x 0 明文**

**bkcrack -C <加密的ZIP文件> -c <ZIP内的文件名> -x <偏移量> <已知明文十六进制>**

成功后会输出3个密钥

step2:用密钥解密文件

**bkcrack.exe -C flag.zip -c flag.png -k 三个密钥 -o result.png**

或者直接解压整个zip文件 前提是你要知道所有的文件名

**bkcrack.exe -C flag.zip -c flag.png -k 三个密钥 -d decrypted.zip**

注意：明文不要空格，要连续写

-x 0表示明文从文件偏移0开始

0️⃣txt文件

flag.zip里面包含一个文件flag.txt

flag.txt的实际内容是flag{16e371fa-0555-47fc-b343-74f6754f6c01}

文件使用ZipCrypto+Store加密

f l a g { 1 6 e 3 7 1 f a - 0 5 5 5 - ... 7 4 f 6 7 5 4 f 6 c 0 1 }
↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑     ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5 6 7 8 9...                    29

明文片段	内容	长度	在原始文件中的偏移
片段 A	lag{16e3	8 字节（连续）	偏移 = 1
片段 B	74f6	4 字节	偏移 = 29

step1：创建包含片段A的明文文件**plain1.txt**

这个片段只包含片段A的连续部分，因为-p参数要求连续明文

echo -n "lag{16e3" > plain1.txt

step2：片段B转十六进制

powershell -Command "$bytes = [System.Text.Encoding]::ASCII.GetBytes('74f6'); -join ($bytes | ForEach-Object { $_.ToString('x2') })"

# 输出: 37346636

step3：运行 bkcrack

bkcrack.exe -C flag_360.zip -c flag.txt -p plain1.txt -o 1 -x 29 37346636

SHCTF2026-Misc-Open my puff

安装openpuff 4.01版本

keyB:qwertyui

keyC:asdfghjk

keyA至少也要八字节 原来说是45678 那在键盘上就是12345678

提取获得一个加密文档 和niimmccw????zfip8+4 已知明文加密

1️⃣png文件

已知png文件魔数

bkcrack.exe -C png4.zip -c 2.png -x 0 89504E470D0A1A0A0000000D49484452
# 已知12字节明文

bkcrack.exe -C png4.zip -c 2.png -k e0be8d5d 70bb3140 7e983fff -d decrypted.png

2️⃣jpg文件

jpg文件头FFD8FFE000104A46494600010100000100010000

bkcrack -C flag.zip -c flag.jpg -x 0 FFD8FFE000104A46494600010100000100010000

如果是exif格式（以FFD8FFE1开头），需要换头，但是JFIF更常见点

3️⃣docx文件

furryCTF2026-Misc-学习资料

构造文件头最方便的方法就是自己创建一个.docx文件 然后把固定的文件头摘录下来

504B03040A0000000000874EE24000000000000000000000000009000000646F6350726F70732F504B

Microsoft Windows [版本 10.0.26200.7623]
(c) Microsoft Corporation。保留所有权利。

C:\Users\13964>cd C:\Users\13964\Desktop\Misc\bkcrack

C:\Users\13964\Desktop\Misc\bkcrack>bkcrack.exe -C flag.zip -c flag.docx -x 0 504B03040A0000000000874EE24000000000000000000000000009000000646F6350726F70732F504B
bkcrack 1.7.0 - 2024-05-26
[15:35:45] Z reduction using 34 bytes of known plaintext
100.0 % (34 / 34)
[15:35:46] Attack on 250815 Z values at index 6
Keys: dc5f5a25 ba003c16 064c2967
82.9 % (207982 / 250815)
Found a solution. Stopping.
You may resume the attack with the option: --continue-attack 207982
[15:37:23] Keys
dc5f5a25 ba003c16 064c2967

C:\Users\13964\Desktop\Misc\bkcrack>bkcrack.exe -C flag.zip -c flag.docx -k dc5f5a25 ba003c16 064c2967 -d decrypted.docx
bkcrack 1.7.0 - 2024-05-26
[15:38:17] Writing deciphered data decrypted.docx
Wrote deciphered data (not compressed).

C:\Users\13964\Desktop\Misc\bkcrack>

furryCTF{Ho0w_D1d_You_C0mE_H9re_xwx}

4️⃣嵌套 ZIP 文件

ISCTF2025-Misc-小蓝鲨的千层嵌套

解压嵌套

每个 ZIP 包含一个加密的 ZIP 文件，例如：

flagggg999.zip 中包含 flagggg998.zip

flagggg998.zip 中包含 flagggg997.zip

…

密码在 ZIP 注释中，格式是：The password is <16位十六进制字符串>

写个脚本逐层解压

1.密码在压缩包的注释区域，具体位置在“The password is”之后，密码为⻓度为16的字符串
2.设flagggg999.zip为初始解压目标，每次解压都会使解压目标后的数字减少1。
3.所有zip文件使用AES256加密
帮我写一个python脚本

import re
import os
import subprocess
import sys

# 如果 7z 不在 PATH 中，请修改为完整路径，例如：
SEVEN_ZIP_PATH = "7z"  # 假设已加入 PATH
# SEVEN_ZIP_PATH = r"C:\Program Files\7-Zip\7z.exe"

def extract_password_from_comment(zip_path: str) -> str:
    """从 ZIP 文件注释中提取密码"""
    try:
        result = subprocess.run(
            [SEVEN_ZIP_PATH, "l", "-slt", zip_path],
            capture_output=True,
            text=True,
            check=True
        )
        # 在 7z 的详细列表输出中查找注释（Comment）
        in_comment_section = False
        comment_lines = []
        for line in result.stdout.splitlines():
            if line.startswith('Comment ='):
                in_comment_section = True
                comment_lines.append(line[9:].strip())
            elif in_comment_section and line.startswith(' '):
                comment_lines.append(line.strip())
            elif in_comment_section and not line.startswith(' '):
                break
        full_comment = ''.join(comment_lines)
        print(f"[+] 注释内容: {repr(full_comment)}")

        match = re.search(r'The password is ([\w\d]{16})', full_comment)
        if match:
            return match.group(1)
        else:
            raise ValueError("未在注释中找到密码")
    except Exception as e:
        print(f"[!] 读取注释失败: {e}")
        raise

def extract_with_7z(zip_path: str, password: str, output_dir: str = "."):
    """使用 7z 解压带密码的 ZIP"""
    try:
        subprocess.run(
            [SEVEN_ZIP_PATH, "x", zip_path, f"-p{password}", f"-o{output_dir}", "-y"],
            check=True,
            stdout=subprocess.DEVNULL,
            stderr=subprocess.DEVNULL
        )
        print(f"[+] 成功解压: {zip_path}")
    except subprocess.CalledProcessError as e:
        raise RuntimeError(f"7z 解压失败: {e}")

def get_next_zip_name(current: str) -> str:
    """将 flagggg999.zip → flagggg998.zip"""
    import re
    match = re.match(r'([a-zA-Z]+)(\d+)\.zip', current)
    if not match:
        raise ValueError(f"无法解析文件名: {current}")
    prefix, num_str = match.groups()
    next_num = int(num_str) - 1
    if next_num < 0:
        return None
    return f"{prefix}{next_num}.zip"

def main():
    current_zip = "flagggg999.zip"

    while current_zip and os.path.exists(current_zip):
        print(f"\n[+] 处理: {current_zip}")

        try:
            # 1. 从注释提取密码
            password = extract_password_from_comment(current_zip)
            print(f"[+] 密码: {password}")

            # 2. 用 7z 解压
            extract_with_7z(current_zip, password)

            # 3. 计算下一个压缩包名
            current_zip = get_next_zip_name(current_zip)

        except Exception as e:
            print(f"[!] 处理 {current_zip} 时出错: {e}")
            break

    print("\n[+] 解压完成！")

if __name__ == "__main__":
    main()

逐层解压直到flagggg3.zip，注释中不再提供密码。题目附件的bkcrackreadme和ZipCrypto Store加密方式，还有题干提示"如果你愿一层一层一层地剥开我的 Zip 你会发现，你会流泪—— 埋在最深处 8+4 的真正奥秘……"提示明文攻击

我们知道一个 ZIP 文件由多个File Entry组成。每个条目以Local File Header开头

Offset   Bytes   Content
0        4       Local file header signature = 0x04034b50 → "PK\x03\x04"
4        2       Version needed to extract
6        2       General purpose bit flag
8        2       Compression method (0 = Store, 8 = Deflate)
10       2       Last mod file time
12       2       Last mod file date
14       4       CRC-32 (may be 0 if Data Descriptor used)
18       4       Compressed size
22       4       Uncompressed size
26       2       File name length (n)
28       2       Extra field length (m)
# 前30字节都是固定的元文件

30       n       File name (e.g., "flagggg2.zip")
# 从偏移30开始是文件名字符串

30+n     m       Extra field
30+n+m   ?       File data (the actual content of the file!)
# 文件名之后才是真正的文件内容

分析flagggg3.zip

• flagggg3.zip中包含加密文件flagggg2.zip
• 根据规律最后解压出来的文件一定是flagggg1.zip
• 那么解压前文件flagggg2.zip是真实的zip文件，其原始内容以 PK\x03\x04 开头，同时，ZIP 文件头中第30字节开始是文件名flagggg2.zip

明文攻击的关键在于加密zip（flagggg3.zip）中某个文件(flagggg2.zip)的部分原始内容，于是分析flagggg2.zip

分析flagggg2.zip 准备明文片段

• 因为 flagggg2.zip 本身是一个 ZIP 文件，它内部也包含一个文件（比如 flagggg1.zip），所以它的 ZIP 结构中：
• 推测flagggg2.zip的二进制数据是

偏移 0:  50 4B 03 04 14 00 00 00 00 00 ...      ← ZIP 魔数 + 元数据
偏移 26: 0C 00                                  ← 文件名长度 = 12 (0x0C)
偏移 28: 00 00                                  ← Extra field 长度 = 0
偏移 30: 66 6C 61 67 67 67 67 31 2E 7A 69 70   ← "flagggg1.zip" 的 ASCII

• 偏移 0：**50 4B 03 04**(已知4字节)
• 偏移 30：文件名 **"flagggg1.zip"**（已知连续12字节）
• 共16字节，满足≥8+4

创建一个attack文件，里面写入"flagggg1.zip"

bkcrack.exe -C flagggg3.zip -c flagggg2.zip -p attack -o 30 -x 0 504b0304

bkcrack.exe -C flagggg3.zip -c flagggg2.zip -k ae0c4b27 66c21cba b9a7958f -d flagggg2_decrypted.zip

ISCTF{3f165c87-c0d4-4903-9c47-3a8d3b9c83df}

5️⃣pyc文件

MiniVN-Misc-D u know Pyc？

https://www.hurkin.top/index.php/2025/d-u-know-pyc%ef%bc%9f%e5%ae%98%e6%96%b9write-up/

关于pyc

.pyc是python源代码编译后的字节码文件

构建pyc头部

1.Magic Number

python 3.12对应的前四字节是cb0d0d0a

2.Bit Field

在python 3.12.12中，Bit Field只有两种状态

00 00 00 00 ——->

后面跟着的是Timestamp和Source Size，然后16位后hash 值置空

(就是全0，会被非预期，所以我手动将其改掉了，但是不会影响pyc的正常功能，对此感兴趣师傅可以自己去构建一下)

01 00 00 00——->

后面跟着的是hash值 至于Bit Field为00 00 00 00，决定了8-12位是TIMESTAMP or HASH

ref(APA): Hurkin.Welcome To Hurk1n's Home!!!.https://www.hurkin.top. Retrieved 2026/1/8.

情况1：Bit Field=00 00 00 00

[魔数][Bit=0][时间戳][文件大小][CodeObject...]

不存在hash值

python只靠“时间+大小”判断是否要重新编译 容易出错

情况2：Bit Field=01 00 00 00

[魔数][Bit=1][时间戳][文件大小][16字节hash][CodeObject...]

存了 hash 值！

python 会对比：当前 .py 的 hash vs .pyc 里存的 hash

一样 → 用缓存

不一样 → 重新编译

坑：Bit Field=00 00 00 00 时 python 根本不读 hash，写 16 个 0x00 也没事；Bit=01 00 00 00 时 hash 全 0 就会出问题。此处 Bit Field 为 00 00 00 00。

3.TimeStamp

从Bandzip看到的修改时间是压缩包保存的时间 而非py文件最后修改时间 不知道

表示为????????

4.File Size

flag.py的原始大小是1411转为4字节的16进制表示是83050000

def dec_to_le_hex(value, byte_length=4):
    """
    将十进制整数转为小端序的十六进制字符串（固定字节数）
    """
    if value < 0:
        raise ValueError("仅支持非负整数")
    if value >= (256 ** byte_length):
        raise OverflowError(f"数值 {value} 超出 {byte_length} 字节表示范围")
    return value.to_bytes(byte_length, byteorder='little').hex()

def main():
    try:
        user_input = input("请输入一个十进制整数: ").strip()
        decimal_num = int(user_input)
        hex_str = dec_to_le_hex(decimal_num, 4)
        print(f"小端序 4 字节十六进制表示: {hex_str}")
    except ValueError as e:
        print(f"输入错误: {e}")
    except OverflowError as e:
        print(f"数值过大: {e}")

if __name__ == "__main__":
    main()

0.pyc Header

于是构建的pyc头部为

CB 0D 0D 0A 00 00 00 00 ?? ?? ?? ?? 83 05 00 00

综上已知CB 0D 0D 0A 00 00 00 00 ?? ?? ?? ?? 83 05 00 00 8+4字节，且偏移量为12。可以进行明文攻击

ref(APA): Hurkin.Welcome To Hurk1n’s Home!!!.https://www.hurkin.top. Retrieved 2026/1/8.

字节	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
值	CB	0D	0D	0A	00	00	00	00	??	??	??	??	83	05	00	00

已知明文攻击

cd C:\Users\13964\Desktop\pyc

.\bkcrack.exe -C flag.zip -c attack_it.pyc -x 0 CB0D0D0A00000000 -x 12 83050000

.\bkcrack.exe -C flag.zip -c flag.py -k d7fe0787 b3af2704 99fa95dc -d flag_decrypted.py

from base64 import b64encode as _B64E
def _u(x):  
    return x
def __r(s):
    t = []
    ln = len(s)
    i = ln - 1
    while i >= 0:
        t.append(s[i])
        i -= 1
    return "".join(t)

def ___x(bts, kk):
    k = kk ^ 0x00
    return bytes((bb ^ k) & 0xFF for bb in bts)
def __rc4(k, d):
    S = list(range(256))
    j = 0
    lk = len(k)
    for i in range(256):
        j = (j + S[i] + k[i % lk]) & 0xFF
        S[i], S[j] = S[j], S[i]
    out = bytearray()
    i = 0
    j = 0
    garbage = 0
    for ch in d:
        i = (i + 1) & 0xFF
        j = (j + S[i]) & 0xFF
        S[i], S[j] = S[j], S[i]
        idx = (S[i] + S[j]) & 0xFF
        kbyte = S[idx]
        garbage ^= (kbyte ^ i ^ j) & 0
        out.append(ch ^ kbyte)
    _ = garbage
    return bytes(out)

def __main_like():
    flag = "VNCTF{?????????}"
    s1 = __r(flag)
    dummy = (len(s1) ^ 0x13) & 0xFF
    if dummy == -1: 
        print("unreachable:", dummy)
    kxor = (0x10 ^ 0x27)
    b1 = s1.encode("utf-8")
    b2 = ___x(b1, kxor)
    fname = "S3ct3t"
    with open(fname, "rb") as f:
        raw = f.read()
    key = _u(raw).strip().replace(b"\r", b"\r").replace(b"\n", b"\n")
    c = __rc4(key, b2)
    c64 = _B64E(c).decode()
    lab = "".join(chr(x) for x in [0x66, 0x69, 0x6e, 0x61, 0x6c]) 
    print(lab, "=>", c64)
if __name__ == "__main__":
    __main_like()

Sect3t.jpg

your-secret-key-here

exp

from base64 import b64decode

def __rc4(k, d):
    # RC4 实现（与原脚本一致）
    S = list(range(256))
    j = 0
    lk = len(k)
    for i in range(256):
        j = (j + S[i] + k[i % lk]) & 0xFF
        S[i], S[j] = S[j], S[i]
    out = bytearray()
    i = 0
    j = 0
    for ch in d:
        i = (i + 1) & 0xFF
        j = (j + S[i]) & 0xFF
        S[i], S[j] = S[j], S[i]
        idx = (S[i] + S[j]) & 0xFF
        kbyte = S[idx]
        out.append(ch ^ kbyte)
    return bytes(out)

# 已知数据
c64 = "adJts2ab4DvAn9Zu60bNyGrOAWj72B1/kg=="
key = b"your-secret-key-here"
kxor = 0x10 ^ 0x27  # 0x37

# Step 1: Base64 decode
c = b64decode(c64)

# Step 2: RC4 decrypt
b2 = __rc4(key, c)

# Step 3: XOR decrypt with kxor
b1 = bytes(bb ^ kxor for bb in b2)

# Step 4: Reverse string
flag = b1[::-1].decode("utf-8")

print("Flag:", flag)

VNCTF{W3lc0me_T0_V&N2025}

6️⃣exe文件

注意：EXE 一般不会以 Store 加密，但加密包里一旦出现 Store 的 EXE 就很好打——PE 明文明显、长度足够。

大部分exe中都有这相同一段，且偏移固定为64：

powershell -Command "$hex = '0E1FBA0E00B409CD21B8014CCD21546869732070726F6772616D2063616E6E6F742062652072756E20696E20444F53206D6F64652E0D0D0A2400000000000000'; $bytes = -split ($hex -replace '..', '0x$& ') | ForEach-Object { [byte]$_ }; [IO.File]::WriteAllBytes('mingwen', $bytes)"

bkcrack.exe -C nc64.zip -c nc64.exe -p mingwen -o 64

bkcrack.exe -C nc64.zip -c nc64.exe -k b21e5df4 ab9a9430 8c336475 -d nc64_decrypted.exe

SHCTF2026-Misc-资源平权！

C:\Users\13964>cd C:\Users\13964\Desktop\Misc\bkcrack

C:\Users\13964\Desktop\Misc\bkcrack>powershell -Command "$hex = '0E1FBA0E00B409CD21B8014CCD21546869732070726F6772616D2063616E6E6F742062652072756E20696E20444F53206D6F64652E0D0D0A2400000000000000'; $bytes = -split ($hex -replace '..', '0x$& ') | ForEach-Object { [byte]$_ }; [IO.File]::WriteAllBytes('mingwen', $bytes)"

C:\Users\13964\Desktop\Misc\bkcrack>bkcrack.exe -C CrackM3.zip -c flag.exe -p mingwen -o 64
bkcrack 1.7.0 - 2024-05-26
[17:16:28] Z reduction using 56 bytes of known plaintext
100.0 % (56 / 56)
[17:16:29] Attack on 140645 Z values at index 71
Keys: 60101051 4cba82cb 48eac20c
33.4 % (47010 / 140645)
Found a solution. Stopping.
You may resume the attack with the option: --continue-attack 47010
[17:16:51] Keys
60101051 4cba82cb 48eac20c

C:\Users\13964\Desktop\Misc\bkcrack>bkcrack.exe -C CrackM3.zip -c flag.exe -k 60101051 4cba82cb 48eac20c -d flag_decrypted.exe
bkcrack 1.7.0 - 2024-05-26
[17:18:08] Writing deciphered data flag_decrypted.exe
Wrote deciphered data (not compressed).

C:\Users\13964\Desktop\Misc\bkcrack>

SHCTF{002c158f-b4d2-4e14-bbbb-b5141bca8cb9}

7️⃣pcapng文件

pcapng（Wireshark 抓包格式）由多个 Block 组成，红色部分绝对固定，直接当已知明文：

1. BlockType 0A 0D 0D 0A——全局魔数（是字节值，不是 ASCII）
2. Byte-Order Magic 4D 3C 2B 1A——小端机器；大端是 1A 2B 3C 4D
3. Version 01 00 00 00——Major=1、Minor=0 小端存储

偏移 8~15 共 8 字节固定：

4D 3C 2B 1A 01 00 00 00

蓝色部分高度可预测：Section Length 标准规定未知写 -1，Wireshark/tcpdump/tshark 默认都写，CTF 里几乎总是 FFFFFFFFFFFFFFFF，偏移 16~23 也可预测：

FF FF FF FF FF FF FF FF

exp

powershell -Command "$hex='4D3C2B1A01000000FFFFFFFFFFFFFFFF'; $bytes = [byte[]]::new($hex.Length / 2); for ($i = 0; $i -lt $bytes.Length; $i++) { $bytes[$i] = [Convert]::ToByte($hex.Substring($i * 2, 2), 16) }; [System.IO.File]::WriteAllBytes('pcap_plain1', $bytes)"

bkcrack.exe -C 3.zip -c capture.pcapng -p pcap_plain1 -o 8

8️⃣rar文件

rar文件头526172211A070000

bkcrack -C flag.zip -c flag.rar -x 0 526172211A070000

9️⃣7z文件

7z文件头377ABCAF271C0002

bkcrack -C flag.zip -c flag.7z -x 0 377ABCAF271C0002

🔟bmp文件

bmp文件头424D36000000000000003600000028000000

bkcrack -C flag.zip -c flag.7z -x 0 424D36000000000000003600000028000000

1️⃣1️⃣gif文件

gif文件头4749463839610000002100000000

bkcrack -C flag.zip -c flag.gif -x 0 4749463839610000002100000000

1️⃣2️⃣wav文件

wav文件头524946468003000057415645666D742010000000

bkcrack -C flag.zip -c flag.wav -x 0 524946468003000057415645666D742010000000

1️⃣3️⃣pdf文件

255044462D312E35

pdf版本号为1.5

bkcrack -C flag.zip -c flag.pdf -x 0 255044462D312E35

如果不确定pdf版本号 也可以试试

255044462D312E34（1.4）

255044462D312E37（1.7）