2026MeowCTF

Misc

隐藏的属性

题目说的很明确了是隐藏的属性,所以我们下载后右键打开属性查看详细信息即可看见flag

flag{Welcome_to_Meow!}

网线的秘密

根据题目意思,大致是有一个图片在数据包里

不难想到需要导出

直接导出对象即可

发现了秘密图片

打开即可看见本题flag

meow{exp0rt_0bj3ct_i5_u53fu1}

神奇的编码

编码题

做的多了应该很显眼

这个是Base64的倒置版本,我们在Base64的编码的时候当原始数据不是3的倍数的时候,最后一组会用=来进行填充,所以=应该出现在末尾

这边明显是倒置的

直接倒置然后Base64解码即可

画画家的礼物

给了一个zip

打开来发现是一个svg文件和一个flag文件

发现压缩方法是Store、加密方法是ZipCrypto

所以怀疑是明文爆破

我们知道,明文爆破至少要满足以下条件

1
2
1,压缩方法是Store/Defalte、加密方法必须是ZipCrypto
2,若压缩方法是Store,则至少已知明文的12个字节及偏移,其中至少8字节需要连续

恰好svg的文件头一般以<svg version=”开头,远不止8位

1
3C 3F 78 6D 6C 20 76 65 72 73 69 6F 6E

我们新建一个这样子的文件,然后直接bkcrack进行爆破即可

1
bkcrack.exe -C gift.zip -c "MeowCTF.svg" -p 1.svg

得到解密所需的key,直接解密即可4648946d edd29655 5434c1f6

1
bkcrack.exe -C gift.zip -k 41bc82d1 3d7ec1b8 22ea8d20 -D 1.zip

得到flag文件发现是个png

改后缀即可得到本题flag

meow{C0ngr@ts_On_mas7ering_known-p1aintext_@ttack}

加密???

看着像伪加密的题目

那在做之前还是先要知道zip伪加密到底是什么

本质上这就是一个没有加密的zip,但是你用来打开它的压缩软件告诉你它“加密了,需要密码”

什么原因导致的呢,就要从加密软件是如何判断一个zip是否加密开始讲起:

一个zip的文件结构通常由三部分组成,即:压缩源文件数据区、压缩源文件目录区、压缩源文件目录结束标志

以此题为例:

在010editor中运行zip模板,灰色部分为压缩源文件数据区,粉色部分为压缩源文件目录区,黄色部分为压缩源文件目录结束标志

详细结构如下

压缩源文件数据区:

压缩源文件目录区:

压缩源文件目录结束标志:

那在一个正常、健康的ZIP文件中,对于同一个文件条目,其压缩源文件数据区和压缩源文件目录区中的“全局方式位标记”(即加密标志, 其中位于数据区的叫做frFlags, 位于目录区的叫做deFlags)必须完全一致。

而解压软件处理ZIP文件通常分两步:

  • 步骤一:列出文件列表

软件首先读取ZIP文件末尾的中央目录(目录区),这里包含了所有文件的索引信息(文件名、加密标志等),软件根据这里的信息向用户展示文件列表,并决定是否给加密文件打上“*”(加密)的图标。

  • 步骤二:解压具体文件

当用户选择解压一个文件时,软件根据中央目录记录的指针,找到文件对应的本地文件头(数据区),软件依据数据区中的标志位来执行实际的解压操作。

如果一个未加密的zip,但是目录区的deFlags被修改,由于压缩软件是首先读取这里然后给我们展示是否加密的,只要这里的deFlags被改为加密,在正常打开压缩包时,就会显示这个文件是加密的

本题目就是如此:

而通过看数据区,我们知道zip本身其实没有加密,因此接下来只需要将目录区的deFlags其改回来即可:

再打开zip就发现已经没有加密了

直接解密提取即可

得到flag:meow{z1p_i5_n0t_r3a11y_3ncrypt3d}

低级的音频

明显是音频隐写题目

看着像摩斯密码

得到HELLOCTF(这边用的在线工具,其实这种直接听然后cyberchef也行

meow{HELLOCTF}

zip(zip(…))

提示看着像爆破,我们看看题目

嗯就是爆破,掩码爆破,前边都一样后边四位掩码一下

利用工具直接设置即可

很快就能恢复,密码是ugsknuw6ukf09nwz

解开来还有下一关,看名字可能还有30层,不能手工了,我们需要编写脚本

注意这边因为是疯狂掩码爆破,最好是多核并行,否则会很慢

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
import zipfile,itertools,string,sys
from multiprocessing import Pool

C=string.ascii_lowercase+string.digits

def crack(a):
path,name,pre,c=a
with zipfile.ZipFile(path) as z:
for x in itertools.product(C,repeat=3):
pwd=(pre+c+''.join(x)).encode()
try:
z.read(name,pwd=pwd)
return pwd
except (RuntimeError,zipfile.BadZipFile):
pass

def solve(path):
with zipfile.ZipFile(path) as z:
name=z.namelist()[0]
pre=z.comment.decode()[:-4]

pwd=None
with Pool() as p:
for r in p.imap_unordered(crack,[(path,name,pre,c) for c in C]):
if r:
pwd=r
p.terminate()
break

with zipfile.ZipFile(path) as z:
open(name,'wb').write(z.read(name,pwd=pwd))

print(f'{path}: {pwd.decode()}')
return name

if __name__=='__main__':
p=sys.argv[1] if len(sys.argv)>1 else 'layer_29.zip'
while p.endswith('.zip'):
p=solve(p)
print('final:',p)

得到flag.txt

meow{Y0u_ar3_g0od_@t_z1p!}

ezforensics

看见mem基本确定考的是内存取证

本题出题人的预期是考notepad.exe进程的文本提取

但问题是notepad.exe的内容会直接存入进程堆里的明文缓冲区

导致我们dump下来的mem文件里边是可以直接搜索字符串搜到的,无需解密或还原结构

所以直接搜就行,不用lovelymem,直接Winhex搜也一样

flag{MeowMeowMeow}

谁偷了我的旗

感觉就是到处找东西(,主要是这些密文都是Base64密文,很好找

找到这三处之后我们手动Base64解码一下,然后放到解密器,试试看顺序就可以了

meow{w31c0me_t0_th3_c4t_f0r3ns1c}得到最后的flag

Gaming Time!

直接下载发现是一个html文件

打开源代码发现直接存在flag

Meow{You_are_good_at_gaming!}

图片隐写:启示

简而言之,flag分了七块,除了第七个都给了提示

第一个直接看属性即可:flag_part1: bWVvd3tJ

第二个发现文件头是jpg的,但是文件尾是png的

所以知道这两个中间可能藏东西了,直接搜索jpg文件尾过来看看

得到第二个flag:

flag_part2: bUBnZV9Td

第三个说要拼接,其实我感觉是分离,直接foremost提取后边的png文件

得到flag_part3:DNnYW4wZ

而flag_part4明显就是左边的破损二维码

这可能是这题最麻烦的一个了,其实直接截图拼图然后补齐定位符也可以,

但是我直接截图拼失败了(),可能没对齐

大不了其实也可以直接手动拼一下

拼接好之后还需要补齐定位符,不过好在不用试,至少没有把顺序再修修改改

最后恢复如上

得到flag_part4

后边也不难理解,LSB隐写

flag_part5: zX3NPX2Z

既然是part5,也就是说弄丢的是part4

所以说数据块应该对应6,在里边搜索后发现6和7在这里边,看上去就是应该zip格式文件但是foremost分离不太出来,我们手动分离一下

都得到flag_part6:Ac2MxbmE

最后的flag_part7也很明显就在下边,修复宽高即可

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
import binascii
import struct

# 打开图片
crcbp = open("photo.png", "rb").read()

# 读取图片中的CRC校验值
crc32frombp = int(crcbp[29:33].hex(), 16)
print("图片中的CRC值:", crc32frombp)

# 枚举所有可能的宽度和高度组合
for i in range(1, 4096): # 宽度1-4095
for j in range(1, 4096): # 高度1-4095
# 构造IHDR块数据(不包括长度字段)
data = crcbp[12:16] + struct.pack('>i', i) + struct.pack('>i', j) + crcbp[24:29]

# 计算CRC32值
crc32 = binascii.crc32(data) & 0xffffffff

# 比较CRC值,如果相同则找到正确的图片尺寸
if crc32 == crc32frombp: # 修复了这里的语法错误
print("找到正确的图片尺寸:")
print("宽度:", i, "高度:", j)
print('十六进制 - 宽度:', hex(i), '高度:', hex(j))
exit(0)

print("未找到匹配的图片尺寸")

我们运行代码CRC爆破,即可得到应该是宽度: 1249 高度: 519

恢复即可得到本题最后一个flag片段,合成后整体Base64解码即可得到答案

bWVvd3tJbUBnZV9TdDNnYW4wZ3JhcGh5XzFzX3NPX2ZAc2MxbmE3aW5nIX0=

meow{Im@ge_St3gan0graphy_1s_sO_f@sc1na7ing!}

ez_MCosint

还有MC的社工题

我好像非预期了,我们先来看一下mitu的预期解

mitu:

题目给了一张游戏截图,需要我们找到这个位置

根据提示mitu喜欢把书架摆在靠北的位置,可以确定方向:

而MC游戏中,存在着一种纹理旋转机制:

我们可以在地上试着放置方块,可以观察到,方块上的贴图纹理不是固定朝向的,而是会有不同的旋转:

并且,在固定的一个坐标上,方块的纹理旋转方式也是固定的!

这就意味着,一片区域内,一群方块的纹理旋转方式排列也是固定的,因此可以通过方块的纹理旋转方式来反推坐标。

这里可以使用https://coordsfinder.com/在线工具来从游戏截图反推坐标:

导入图片,根据提示步骤进行:

第一步是选择一面区域(这里要判断好格数):

然后选择面的朝向,图中很明显是朝向上的:

第二部是确定方向,根据提示书架位于北边:

直接设置即可

接下来是设置每一格的纹理,这里工具可以自动分析,但手动的准确率更高一些:

选中方块,在右边对比纹理,然后从四种旋转方式中进行选择:

如上图一致即为设置成功

接着设置完所有格子:

接着在export中设置范围,即距离原点半径2000格:

运行后很快就可以找到具体的坐标:

这里的坐标是工具内起始格(标注XY箭头)的坐标:

根据方向延申,可以确定箱子的坐标为 628,-48,479 (箱子要高出一格)

因此flag为: meow{628,-48,479}

当然,题中给了mc版本和地图种子,我们可以直接创建世界,传送到工具找到的坐标处也可

然后在对应位置按F3,获取坐标

meow{628,-48,479}

玫幽倩:

欸题目只给了一个图片,不过根据这个图片不难想到人工的都是mitu自己摆的

我们该观察的其实更应该是那些自然景观,比如右上角的

很有特征嘛

1
2
3
4
凝灰岩 凝灰岩       凝灰岩      凝灰岩
凝灰岩 深层红石矿石 凝灰岩 凝灰岩
空气 凝灰岩 深层红石矿石 凝灰岩
空气 空气 深板岩 凝灰岩

直接搜这个特征就好了,我们先根据版本号和种子生成一个世界

之后直接对这个世界的存档文件,根据这个特征,对半径2000进行检索

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
import os, sys, zlib, gzip, struct, json
from concurrent.futures import ProcessPoolExecutor
import numpy as np

REGION_DIR = r"G:\ctf\pregen\server\world\dimensions\minecraft\overworld\region"
OUT = r"G:\ctf\pregen\scan_out"

class P:
__slots__ = ("d", "i")
def __init__(self, d): self.d = d; self.i = 0
def u1(self):
v = self.d[self.i]; self.i += 1; return v
def fmt(self, f, n):
v = struct.unpack_from(f, self.d, self.i)[0]; self.i += n; return v
def s(self):
n = struct.unpack_from('>H', self.d, self.i)[0]; self.i += 2
v = self.d[self.i:self.i+n]; self.i += n
return v.decode('utf-8', 'replace')
def payload(self, t):
if t == 1: return self.fmt('>b',1)
if t == 2: return self.fmt('>h',2)
if t == 3: return self.fmt('>i',4)
if t == 4: return self.fmt('>q',8)
if t == 5: return self.fmt('>f',4)
if t == 6: return self.fmt('>d',8)
if t == 7:
n = self.fmt('>i',4); v = self.d[self.i:self.i+n]; self.i += n; return v
if t == 8: return self.s()
if t == 9:
it = self.u1(); n = self.fmt('>i',4)
if it == 0: return []
if it in (1,2,3,4,5,6):
sz = {1:1,2:2,3:4,4:8,5:4,6:8}[it]
fk = {1:'>i1',2:'>i2',3:'>i4',4:'>i8',5:'>f4',6:'>f8'}[it]
v = np.frombuffer(self.d, fk, n, self.i); self.i += sz*n
return f'<prim x{n}>'
return [self.payload(it) for _ in range(n)]
if t == 10:
d = {}
while True:
tt = self.u1()
if tt == 0: return d
name = self.s()
d[name] = self.payload(tt)
if t == 11:
n = self.fmt('>i',4); v = np.frombuffer(self.d, '>i4', n, self.i); self.i += 4*n; return v
if t == 12:
n = self.fmt('>i',4); v = np.frombuffer(self.d, '>i8', n, self.i); self.i += 8*n; return v
raise ValueError('bad tag')

AIR_IDS = {'minecraft:air', 'minecraft:cave_air', 'minecraft:void_air'}

def decode_indices(data, n, palette_len):
bits = max(4, (palette_len - 1).bit_length())
per = 64 // bits
longs = np.frombuffer(data, dtype=np.uint64).byteswap()
idx = np.arange(n)
li = idx // per
sh = (idx % per).astype(np.uint64) * np.uint64(bits)
mask = np.uint64((1 << bits) - 1)
return ((longs[li] >> sh) & mask).astype(np.uint16)

# pattern template: T=tuff O=deepred A=air D=deepslate .=don't care
# rows = z (row0 north side drawn first), cols = x
TEMPLATE = [
list("TTTT"),
list("TOT T".replace(" ", "")),
list("ATOT"),
list("AADT"),
]
def norm(t):
return [list(row) for row in t]
TEMPLATE = [["T","T","T","T"],["T","O","T","T"],["A","T","O","T"],["A","A","D","T"]]

def rot90(m):
return [list(row) for row in zip(*m[::-1])]
def mirror(m):
return [row[::-1] for row in m]

variants = []
m = TEMPLATE
for k in range(4):
variants.append([row[:] for row in m])
variants.append(mirror(m))
m = rot90(m)

def process_region(path):
out = []
data = open(path, 'rb').read()
if len(data) < 8192: return out
for i in range(1024):
b = data[i*4:i*4+4]
off = (b[0] << 16) | (b[1] << 8) | b[2]
if off == 0 or b[3] == 0: continue
start = off * 4096
if start + 5 > len(data): continue
ln = struct.unpack_from('>I', data, start)[0]
if start + 4 + ln > len(data): continue
comp = data[start+4]
raw = data[start+5:start+4+ln]
try:
raw = zlib.decompress(raw) if comp == 2 else (gzip.decompress(raw) if comp == 1 else raw if comp == 3 else None)
except Exception:
continue
if raw is None: continue
try:
p = P(raw); t = p.u1(); p.s(); d = p.payload(t)
except Exception:
continue
if not isinstance(d, dict): continue
if d.get('Status') not in ('minecraft:full', 'full'): continue
cx, cz = d.get('xPos'), d.get('zPos')
if cx is None: continue
for s in d.get('sections', []):
sy = int(s.get('Y', -999))
if not (-6 <= sy <= 2): continue
bs = s.get('block_states')
if bs is None: continue
pal = [e.get('Name', '?') for e in bs.get('palette', [])]
has_tuff = any(n.endswith(':tuff') for n in pal)
has_dro = any(n == 'minecraft:deepslate_redstone_ore' for n in pal)
if not (has_tuff and has_dro): continue
dt = bs.get('data')
if dt is None: continue
# class ids: 0 air, 1 tuff, 2 deepslate_redstone_ore, 3 deepslate-ish, 4 other
cls = np.full(len(pal), 4, dtype=np.uint8)
for k, n in enumerate(pal):
if n in AIR_IDS: cls[k] = 0
elif n == 'minecraft:tuff': cls[k] = 1
elif n == 'minecraft:deepslate_redstone_ore': cls[k] = 2
elif 'deepslate' in n: cls[k] = 3
ind = decode_indices(dt, 4096, len(pal))
# (y, z, x) after reshape
vol = cls[ind].reshape(16, 16, 16) # (y, z, x)
for yy in range(16):
sl = vol[yy] # (z, x)
for vi, tmpl in enumerate(variants):
# slide 4x4
for zz in range(13):
for xx in range(13):
ok = True
for dz in range(4):
for dx in range(4):
ch = tmpl[dz][dx]
if ch == '.': continue
want = {'T':1, 'O':2, 'A':0, 'D':3}[ch]
got = int(sl[zz+dz, xx+dx])
if want == 3:
if got != 3 and got != 4: ok = False; break
elif got != want:
ok = False; break
if not ok: break
if ok:
wy = sy*16 + yy
out.append((cx*16+xx, wy, cz*16+zz, vi))
return out

def main():
files = [os.path.join(REGION_DIR, f) for f in os.listdir(REGION_DIR) if f.endswith('.mca')]
print(f"[*] {len(files)} region files", flush=True)
hits = []
with ProcessPoolExecutor(max_workers=12) as ex:
for res in ex.map(process_region, files, chunksize=1):
hits.extend(res)
print(f"[*] pattern hits: {len(hits)}", flush=True)
for h in hits:
print(" x=%d y=%d z=%d variant=%d" % h)
with open(os.path.join(OUT, 'pattern_hits.json'), 'w') as f:
json.dump(hits, f)

if __name__ == '__main__':
main()

运行即可得到结果,发现只有一个(如果有很多就尽可能再扩大检索特征)

我们直接tp过去看看

1
/tp @p 636 -45 473

就能看见是下边这个几乎一模一样的地方

站到箱子在的地方

即可得到本题flag是meow{628,-48,479}

画画家Final

本题考察windows的mspaint进程取证。

  1. 使用volatility进行内存取证

附件为.dmp,这是windows内存转储文件。结合题目提示这是完整的系统物理内存转储,因此可以使用volatility进行取证。

同时我们注意到,附件名字为Win7SP1x64,可以知道系统是win7 64位版本,也就可以指定profile=Win7SP1x64

题目中描述画画家在电脑中作画,但是电脑出现故障,画作没来得及保存就丢失了。

我们可以先使用pslist插件查看内存中的系统进程:

python2 vol.py -f /home/kali/Desktop/Win7SP1x64.dmp --profile=Win7SP1x64 pslist

可以发现mspaint进程,mspaint.exe 指的是微软的画图程序

可以判断,画画家正是使用该软件进行画图的,因此我们要做的是从该进程恢复图像。

mspaint.exe的PID为1192,使用memdump插件对进程进行提取:

python2 vol.py -f /home/kali/Desktop/Win7SP1x64.dmp --profile=Win7SP1x64 memdump -p 1192 --dump-dir=./

得到1192.dmp,这就是画图程序在内存中的原始图像数据

接下来要加载原始图像数据,需要使用工具GIMP:

更改文件后缀名为.data,使用gimp打开(选择文件类型为图像数据data):

之后我们需要调整位移和宽高,以显示出原始的图像.

题目中告诉我们宽高是704*63

此时手动调整位移,直至显示出flag:

打开图片:

竖直反转后得到flag:

flag{YOu_ar3_g0od_@_Mspaint_F0rensics}

  1. 使用lovelymem内存取证工具进行取证

在进程分析中找到mspaint进程

点击可视化进程内存,同样调整宽高和偏移,得到flag:

或使用GDI位图恢复功能,自动恢复出图像:

flag{YOu_ar3_g0od_@_Mspaint_F0rensics}


2026MeowCTF
https://mei-you-qian.github.io/2026/10/09/2026MeowCTF/
作者
Meiyouqian
发布于
2026年10月9日
许可协议