2018 网鼎杯-第三场 WriteUp

📝 赛事概况

  • 比赛赛制：采用线上 CTF（夺旗赛） 模式。参赛队伍通过解题获取 Flag 以获得分数

  • 参赛对象：主要面向电子政务、科技、互联网企业、网信等行业

  • 参赛规模：据当时报道，共有 1483 支队伍参与本场比赛的角逐

  • 晋级规则：线上预选赛每场取前 50 名晋级线下半决赛，四场共计 200 支队伍入围

Reverse

最好的语言（Python 字节码）

pasted_1784357937528_0wa08t.png

下载附加识别字符串发现是 Python2 字节码文件

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
su2es2@Suc2es2:/mnt/d/CTF/213_79e9610e96eb501c77b8d1cae8536dfcc64f58c0/最好的语言$ strings re
magic 03f30d0a
moddate 6d4a695b (Tue Aug  7 15:29:49 2018)
<code>
   <argcount> 0 </argcount>
   <nlocals> 0</nlocals>
   <stacksize> 5</stacksize>
   <flags> 0040</flags>
   <code>
      6400006401006c00005a00006400006402006c01006d02005a0200016400
      006401006c03005a03006400006401006c04005a04006403005a05006404
      008400005a06006405008400005a07006506006505006406002083010065
      070065050064060064070021830100176506006505006407001f83010017
      5a08006500006a090065080083010047486408005a080064010053
   </code>
   <names> ('base64', 'hashlib', 'md5', 'random', 'string', 'f', '_', '____', 'e', 'b64encode')</names>
   <varnames> ()</varnames>
   <freevars> ()</freevars>
   <cellvars> ()</cellvars>
   <filename> 're2.py'</filename>
   <name> '<module>'</name>
   <firstlineno> 1</firstlineno>
   <consts>
      -1
      None
      ('md5',)
      'flag{*******}'
      <code>
         <argcount> 1 </argcount>
         <nlocals> 4</nlocals>
         <stacksize> 8</stacksize>
         <flags> 0043</flags>
         <code>
            6401006a00007401006a02007403006a04006402008302008301007d0100
            6401007d02007846007405007406007c0000830100830100445d32007d03
            007c02007407007408007c00007c0300198301007408007c01007c030064
            0200161983010041830100377d0200713700577c020053
         </code>
         <names> ('join', 'random', 'sample', 'string', 'digits', 'range', 'len', 'chr', 'ord')</names>
         <varnames> ('b', '__', '___', 'i')</varnames>
         <freevars> ()</freevars>
         <cellvars> ()</cellvars>
         <filename> 're2.py'</filename>
         <name> '_'</name>
         <firstlineno> 7</firstlineno>
         <consts>
            None
            ''
            4
         </consts>
         <lnotab> 00011e01060119013001</lnotab>
      </code>
      <code>
         <argcount> 1 </argcount>
         <nlocals> 2</nlocals>
         <stacksize> 2</stacksize>
         <flags> 0043</flags>
         <code>
            7400008300007d01007c01006a01007c0000830100017c01006a02008300
            0053
         </code>
         <names> ('md5', 'update', 'digest')</names>
         <varnames> ('a', '___')</varnames>
         <freevars> ()</freevars>
         <cellvars> ()</cellvars>
         <filename> 're2.py'</filename>
         <name> '____'</name>
         <firstlineno> 14</firstlineno>
         <consts>
            None
         </consts>
         <lnotab> 000109010d01</lnotab>
      </code>
      12
      19
      'U1VQU05pSHdqCEJrQu7FS7Vngk1OTQ58qqghXmt2AUdrcFBBUEU='
   </consts>
   <lnotab> 0c0110010c010c020601090709052f010e01</lnotab>
</code>

根据字节码还原脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import base64
from hashlib import md5
import random
import string

f = 'flag{*******}'

def _(b):
    key = ''.join(random.sample(string.digits, 4))
    res = ''
    for i in range(len(b)):
        res += chr(ord(b[i]) ^ ord(key[i % 4]))
    return res

def ____(a):
    m = md5()
    m.update(a)
    return m.digest()

e = _(f[:12]) + ____(f[12:19]) + _(f[19:])
print base64.b64encode(e)

e = 'U1VQU05pSHdqCEJrQu7FS7Vngk1OTQ58qqghXmt2AUdrcFBBUEU='

程序把 flag 分成三段

1
2
3
4
5
6
7
f[:12]
f[12:19]
f[19:]

第 1 段：前 12 字符
第 2 段：第 12 到 18 位，共 7 字符
第 3 段：第 19 位到结尾

加密方式为

1
e = _(f[:12]) + ____(f[12:19]) + _(f[19:])

其中 _() 是 XOR 加密

key 是 4 位互不重复的数字

1
key = ''.join(random.sample(string.digits, 4))

然后循环异或

1
cipher[i] = plain[i] ^ key[i % 4]

而 ____() 是 MD5

1
md5(flag[12:19]).digest()

所以密文结构为

1
2
3
4
5
Base64(
    XOR(flag[:12], 4位数字key1)
  + MD5(flag[12:19])
  + XOR(flag[19:], 4位数字key2)
)

先解码目标字符串结果长度为 38

因为中间 MD5 digest 固定是 16 字节，所以可以切成

1
2
3
c1 = data[:12]
h  = data[12:28]
c3 = data[28:]

分别是

1
2
3
c1 长度：12
h  长度：16
c3 长度：10

这说明原始 flag 长度为 12 + 7 + 10 = 29

第一段是 XOR(flag[:12], key1)，而 flag 开头固定为 flag{，密文是 535550534e6948776a08426b

计算

1
2
3
4
5
key[0] = c1[0] ^ ord('f')
key[1] = c1[1] ^ ord('l')
key[2] = c1[2] ^ ord('a')
key[3] = c1[3] ^ ord('g')
key[0] = c1[4] ^ ord('{')

得到结果 59145，第 5 位再次得到 5，说明 key 是循环的四位随机数

解密第一段密文得到 flag{PyC_1s_

爆破第二段密文 MD5 得到 613u21i

最后第三段密文的 Key 可以直接爆破，因为最后一位一定是 }

密钥是 4813，最后得到 _N0t_Hard}

所以 flag 就是 flag{PyC_1s_613u21i_N0t_Hard}

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
import base64
import itertools
import string

# Base64 编码的密文，内部结构为：加密前缀(12字节) + MD5哈希(16字节) + 加密后缀
target = "U1VQU05pSHdqCEJrQu7FS7Vngk1OTQ58qqghXmt2AUdrcFBBUEU="
data = base64.b64decode(target)

# 拆分三段
c1 = data[:12]       # 前12字节：flag 前缀部分的密文
md5_part = data[12:28]  # 中间16字节：flag 中间部分的 MD5 哈希
c3 = data[28:]        # 剩余字节：flag 后缀部分的密文

def xor(c, k):
    """循环异或解密：c 为密文字节串，k 为密钥字符串"""
    kb = k.encode()
    return bytes(c[i] ^ kb[i % len(kb)] for i in range(len(c)))

# ---------- 第一部分：恢复 flag 前缀 ----------
# 已知 flag 以 "flag{" 开头，与密文前5字节异或得到密钥流
# 题目使用的异或密钥长度为 4，因此取密钥流前 0 4字节作为 key1
key1 = bytes(c1[i] ^ b"flag{"[i] for i in range(5))[:4].decode()
part1 = xor(c1, key1).decode()   # 解密出完整的第一部分

# ---------- 第二部分：中间字符串 ----------
middle = "613u21i"

# ---------- 第三部分：爆破后缀 ----------
charset = string.ascii_letters + string.digits + "_{}"  # 合法字符集
# 密钥是4位不重复的数字，对 0-9 的所有排列进行尝试
for digits in itertools.permutations(string.digits, 4):
    k = ''.join(digits)
    try:
        text = xor(c3, k).decode()
        # 检查解密结果是否符合 flag 后缀的特征
        if text.startswith("_") and text.endswith("}") and all(c in charset for c in text):
            part3 = text
            break
    except UnicodeDecodeError:
        continue

# 拼接得到完整 flag
flag = part1 + middle + part3

babyre（VB.NET）

pasted_1784361347609_3w5799.png

VB.NET 逆向需要使用 dnSpyEx

pasted_1784362602549_9ldoff.png

构造函数 Form1() 中初始化

1
this.contents = "flag{ca201ed0-9e07";

Form1_Load 方法中两次追加字符串

1
2
this.contents = ptr + "-11e8-b6dd";
this.contents = ptr + "-000c29dcabfd}";

最终 contents 的值为 flag{ca201ed0-9e07-11e8-b6dd-000c29dcabfd}

Misc

mirror（文件附加隐写）

pasted_1784363528258_jibvq1.png

JPEG 图片末尾附加的一张整体字节倒序的 PNG 图片，提取出来拿到 flag

pasted_1784363860071_5f3ayd.png

Unpleasant_music（WAV 波形振幅隐写 + RAR 修复 + 文件后缀篡改 + PNG 宽高篡改）

附件是一个 WAV 文件，放大波形后发现像 01 序列，判断方式：

  • 每一个周期内，如果最大振幅较高，记为 1

  • 如果最大振幅较低，记为 0

  • 周期边界可以通过波形从负值跨到非负值的位置判断，也就是零交叉点

pasted_1787205576480_cjuvda.png

思路是读取 WAV 所有采样点，将音频字节转成 short 数组，然后在每个周期内统计最大值，阈值约为 24000，超过则记 1，否则记 0。最后每 4 bit 转成 1 个十六进制字符，再按 hex 写入二进制文件

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
import wave
import codecs
import numpy as np

# 打开 WAV 文件，读取全部音频帧
wavfile = wave.open("music.wav", "rb")
params = wavfile.getparams()
nframes = params[3]             # 总帧数

datawav = wavfile.readframes(nframes)
wavfile.close()

# 将 16-bit PCM 音频数据解析为有符号短整型采样点
datause = np.frombuffer(datawav, dtype=np.short)

result_bin = ""
result_hex = ""

mx = 0                            # 当前周期的最大幅值

for i in range(len(datause) - 1):
    # 更新当前周期的峰值
    if datause[i] > mx:
        mx = datause[i]

    # 当采样值从负跨到非负时，认为一个周期结束
    if datause[i] < 0 and datause[i + 1] >= 0:
        # 根据周期峰值大小判断隐藏比特
        if mx > 24000:
            result_bin += "1"
        else:
            result_bin += "0"

        # 重置峰值，开始下一个周期
        mx = datause[i + 1]

# 每 4 个 bit 转换为一个十六进制字符
for i in range(0, len(result_bin), 4):
    chunk = result_bin[i:i + 4]
    if len(chunk) == 4:
        result_hex += hex(int(chunk, 2))[2:]

print("bits:", len(result_bin))
print("hex head:", result_hex[:32])

pasted_1787206447507_zzb6ku.png

52 61 72 21 对应 ASCII 字符 Rar!，这说明音频里藏的是一个 RAR 压缩包，将下面代码添加上去

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 裁掉最后不足 1 字节的 bit，确保长度是 8 的倍数
result_bin = result_bin[:len(result_bin) // 8 * 8]

# 用 bytearray 存储转换后的字节
data = bytearray()

# 每 8 个 bit 组成 1 个字节
for i in range(0, len(result_bin), 8):
    byte = int(result_bin[i:i+8], 2)   # 二进制字符串 → 整数
    data.append(byte)                  # 追加到字节数组

# 将字节数组写入文件
with open("result.rar", "wb") as f:
    f.write(data)

用 7-Zip 打开看到一个 .txt 文件，但是解压失败

pasted_1787206613986_lkm95r.png

RAR 是由多个 block 组成的。每个 block 前面有这些字段

1
2
3
4
5
HEAD_CRC
HEAD_TYPE
HEAD_FLAGS
HEAD_SIZE
ADD_SIZE

常见 HEAD_TYPE 如下

1
2
3
4
5
0x72  marker block
0x73  archive header
0x74  file header
0x7a  subblock
0x7b  terminator

010 发现有一个块的 HEAD_TYPE 是 0x7a，但结合块的具体信息，它很可能原本应该是一个 PNG，也就是 0x74

pasted_1787206905455_pqru59.png

解压文件发现多出 STM 文件，修改文件后缀名为 PNG 打开发现为半张二维码

pasted_1787207737767_9bd3nj.png

修改宽高，实际尺寸为 280×280

pasted_1787207794130_bhbamo.png

扫描拿到二维码

pasted_1787207810626_fiwhem.png

Crypto

hafuhafu（分解 n）

pasted_1784364327934_h2kdnu.png

直接分解出

1
2
p = 149930380465516707151079321019435489399072155945793735032334088844599773034021170995501688132861944516938448679935403246643441984203770825485165700862168437691254557323938150173733659070945061763789341407547559935070758242521126066900261360899379463301621378242061934281538210192731229473900396425739817670867
q = 170559166199281256887953076784727902849936084815549184550874370897326056825177365209113910954088389779180174518262922176726833811470419181874717574929460298509184863124213663255559781224744696195678069242025195218017449489985102637547369070225979448169459840545693721393354651993457943927480894225788038743661

最后解出 flag{D0nT_uS3_Th3_kN0w_n}